1. 理解文件系统

1.2 背景知识

1.有没有一些被打开的文件吗？在哪里？
有。在磁盘里。磁盘级文件

2.我们学习磁盘级别的文件，我们的侧重点在哪里？
衍生问题：
单个文件角度——这个文件在哪里？这个文件多大？这个文件的其他属性是什么？……
系统角度——一共有多少个文件？各自属性在哪里？如何快速找到？我还可以存储多少个文件？如何快速的找到指定的文件？……
如何进行对磁盘文件进行分门别类的存储，用来支持更好的存取？

3.磁盘文件——了解磁盘
内存——掉电易失存储介质
磁盘——永久性存储介质（不止是磁盘）——SSD（固态硬盘）（现在笔记本上应该都是这个，但贵）、U盘、flash卡、光盘、磁带
结论：磁盘是一个外设，同时还是我们计算机中唯一的一个机械设备——慢！（对比出来的）——所以OS一定会有一些提速的方式

4.磁盘结构
物理结构：
磁盘盘片、磁头、伺服系统、音圈马达……
盘面上会存储数据——计算机只认识二进制（两态）——南极北极、有电没电、正负——向磁盘写入，本质就是改变磁盘上的正负性——磁头来改变
磁盘寻到的过程
 
存储结构：
磁道，扇区，柱面
扇区是磁盘存储的基本单位 512字节 4KB 硬件上的
在物理上，如何把数据写入到指定的扇区里？——本质就是如何找到一个扇区？
1.确定在哪一个面上（对应的就是确定哪一个磁头）
2.在哪一个磁道（柱面）上
3.在哪一个扇区上
这就是CHS寻址
如果我们有了CHS，就能找到任意一个扇区，那么所有的扇区我们都能找到。
 
抽象结构：（虚拟、逻辑）结构
磁盘盘片：圆形结构——线性结构
sector disk[10241024n];数组
访问一个扇区，只要知道数组的下标
把磁盘想像成一个大数组

将数组存储到磁盘——将数据存储到该数组
找到磁盘特定扇区的位置——找到数组特定的位置
对磁盘的管理——对该数组的管理

对磁盘的管理——对一个小分区的管理——继续分区
boot block——block group 0—— ——block group n
block group n：
super block——group descirptor table ——block bitmap——inode bitmap——inodetable——data blocks
虽然磁盘的基本单位是扇区（512字节），但是OS（文件系统）和磁盘进行IO交互的基本单位是：4KB（8*512字节）。——block大小——磁盘：块设备。
为什么不以512字节为单位呢？
1.太小。会导致多次IO，进而导致效率的降低
2.如果os使用和磁盘一样的大小，万一磁盘的基本大小变量的话，os的源代码也要改。所以硬件和软件（os）需要进行解耦。

文件 = 内容+属性
linux在磁盘上存储文件的时候，是将内容和属性分开存储（管理）的。

• 超级块（Super Block）：存放文件系统本身的结构信息。文件系统的属性信息 Data
• blocks：多个4KB(扇区*8）大小的集合，保存的都是特定文件的内容 inode
• Table：inode是一个大小为128字节的空间，保存的是对应文件的属性。该组块内，所有文件的inode空间的集合，需要标识唯一性，每一个inode块，都要有一个inode编号！一般而言，一个文件，一个inode，一个inode编号
• BlockBitmap：假设有10000+个blocks，10000+比特位：比特位和特定的block是一一对应的，其中比特位为1，代表该block被占用，否则表示可用
• inode Bitmap：假设有10000+个inode结点，就有10000+个比特位，比特位和特定的inode是一一对应的，其中比特位为1表示inode被占用，否则表示可用。
• Group Descriptor Table（GDT）：快组描述符，这个快组多大，已经使用多少了，有多少个inode，已经占用了多少个，还剩多少，一共有多少个block，使用了多少……
  这些都是能够让一共文件的信息可追溯，可管理
  格式化

一个文件只对应一共inode属性节点，inode编号
一个文件只能有一个block吗？不一定

1.哪些block属于同一个文件？
inode里面定义了一个数组，里面可以保存块的编号

struct inode
{
    //文件的大小
    //文件的inode编号
    //其他属性
    int blocks[15];
    
}


blocks[0] = 6;
blocks[0] = 7;
blocks[0] = 8;

2.找到文件，只要找到文件对应的inode编号就可以找到该文件的inode属性集合，可是文件的内容呢？
也是通过数组，映射表，找到

3.那如果这个文件特别大怎么办？
data block中，不是所有的data block只能存文件数据，它也可以存其他块的块号——间接索引——找到大量的块——类似多叉树结构（二级、三级）

 

1.2 inode vs 文件名

df -h查看 分区
找到文件：inode编号——分区特定的bg——inode——属性——内容

怎么知道inode编号？
我们之前打开文件一直用的是文件名
linux中，inode属性里面，没有文件名这样的说法！
补充知识：
1.一个目录下，可以保存很多文件，但是这些文件都没有重复的文件名！
2.目录是文件吗？是——有自己的inode，有自己的data block——data block里存的是文件名与inode编号的映射关系。两者互为key值
3.进入目录（需要x权限）——创建文件（需要w权限）——显示文件名与属性（r权限）
所以inode编号是依托于目录结构的

创建文件，系统做了什么？
根据文件系统在整个分区SuperBlock找到目录所对应的分区与块组——确定文件存储的块——去inodeBitmap里遍历位图，找到0的比特位置为1，同时拿到了一个inode号（遍历的时候做一个计数器不断累加）——拿到了inode编号——在inodeTable里把属性写进去（编号，文件权限，拥有者所属组，时间，大小……）——因为是新文件，是空的，将datablock映射的数组全部置为0
文件名：用户
inode：filesystem
创立映射关系

删除文件，系统做了什么？
找到目录对应的data block——以文件名作为key值去找到对应的inode的——将inodeBitmap对应的比特位由1置0，blockBitmap数据块的位图由1置0——再将文件名与inode的映射关系去掉
只需要将文件内容设置为无效，没有做覆盖。
无论是linux还是Windows删了都能恢复——删除日志
前提：inode编号，没有被使用，inode和datablock没有被重复占用
所以重要文件被删除之后，什么都不要做，不然会误覆盖

查看文件，系统做了什么？
目录——inodetable——datablock——文件名：inode

分区，格式化——在磁盘写入文件系统
inode是固定的，datablock是固定的
系统还有空间，但是创建文件失败：
inode还有，但是没有数据块了
数据块还有，但是没有inode了

1.3 软硬链接

ls -li
显示文件属性和inode编号

软链接有自己独立的inode——413
硬链接的inode——340

区别：有没有独立的inode
1.软链接有自己独立的inode——软链接是一个独立的文件
特性：软链接的文件内容是指向的文件对应的路径
应用：相当于Windows中的快捷方式
 
2.硬链接没有独立的inode——硬链接不是一个独立的文件0
创建硬链接不是真正的创建新文件——只是在指定目录下，建立了文件名和指定inode的映射关系
属性链接关系数字：1——2——1（硬链接数）
当我们删除一个文件的时候，并不是把这个文件的inode删除，而是将这个文件的inode引用计数–，当引用计数为0的时候，这个文件才被真正的删除——为0时就是没有文件名与其关联——没有用户关心这个文件了

为什么创建一个文件，硬链接数默认是1——一条关系
空目录默认是2——目录本身与inode一条关系，dir里包含了.和…（文件名）也与inode也有一条关系 = 2

acm
Access 最后访问时间
Modify 文件内容最后修改时间
Change 属性最后修改时间

 
 

2. 动态库和静态库

为使用别人的库做准备

2.1 静态库.a

2.1.1 如果想写一个库？（编写库的人的角度）

库里面要不要main函数呢？不要！
mkdir mklib
Makefile

libhello.a: mymath.o myprint.o
ar -rc libhello.a mymath.o myprint.o
mymath.o:mymath.c
gcc -c mymath.c -o mymath.o
myprint.o:myprint.c
gcc -c myprint.c -o myprint.o

.PHONY:hello
hello:
mkdir -p hello/lib
mkdir -p hello/include
cp -rf *.h hello/include
cp -rf *.a hello/lib

.PHONY:clean
clean:
rm -rf *.o libhello.a hello

mymath.c

#include "mymath.h"


int addToTarget(int from, int to)
{
    int sum = 0;
    for(int i = from; i <= to; i++)
    {
        sum += i;
    }

    return sum;
}

mymath.h

#pragma once

#include<stdio.h>

extern int addToTarget(int from, int to);

myprint.c
#include "myprint.h"

void Print(const char *str)
{
    printf("%s[%d]\n", str, (int)time(NULL));
}

myprint.h

#pragma once

#include <stdio.h>
#include <time.h>

extern void Print(const char *str);


mkdir uselib
main.c
#include "myprint.h"
#include "mymath.h"


int main()
{
    Print("hello world");
    int res = addToTarget(1,100);

    printf("res: %d\n", res);

    return 0;
}

main函数也在这个文件夹里
gcc main.c mymath.c myprint.c -o my.exe
./my.exe
hello world

main函数在另一个文件夹里
gcc -c mymath.c -o mymath.o
gcc -c myprintf.c -o myprintf.o
main.o
三个.o一链接就可以形成可执行程序了
gcc main.o mymath.o myprintf.o -o my.exe

如果我只把.h 和.o给别人用，可以吗？可以
.o文件太多了，麻烦。
可以把所有.o打包——这个过程就叫形成静态库
库的前缀必须是lib，后缀必须是.a，文件名可以随便取
ar 归档工具
ar -rc libhello.a mymath.o myprintf.o

 

2.1.2如果我把库给别人，别人怎么用呢？（使用库的人的角度）

头文件gcc的默认搜索路径是：/usr/include
库文件的默认搜索路径是：/lib64 或者 /usr/lib64

1.sudo cp hello/include/* /usr/inlcude/ -rf
2.sudo cp -rf hello/lib/libhello.a /lib64
会形成一个hello目录

gcc main.c 报错
自己写的库属于第三方库 （安装静态库
gcc main.c -hello
才会编译通过

我们刚刚拷贝到系统的默认路径下，就叫做库的安装
记得删掉，不要随便安装到系统路径

3.硬使用这个库
gcc main.c -I ./hello/include/ -L ./hello/lib/ -lhello
-I:头文件搜索路径
-L:库文件搜索路径
-lhello:指定在特定路径下，使用的库

静态库被使用时是拷贝进可执行程序内部

 

2.2 动态库.so

2.2.1站在制作库工程师的角度——动态库

静态库——地址确定（绝对地址）
动态库——地址不确定
一静一动

gcc -fPIC -c mymath.c -o mymath.o
gcc -fPIC -c myprintf.c -o myprintf.o
-fPIC形成一个与位置无关的二进制文件

将所有.o打包形成动态库
gcc -shared myprintf.o mymath.o -o libhello.so

一次形成两个库：
Makefile

.PHONY:all
all:libhello.so libhello.a

libhello.so:mymath_d.o myprint_d.o
        gcc -shared mymath_d.o myprint_d.o -o libhello.so
mymath_d.o:mymath.c
        gcc -c -fPIC mymath.c -o mymath_d.o
myprint_d.o:myprint.c
        gcc -c -fPIC myprint.c -o myprint_d.o

libhello.a: mymath.o myprint.o
ar -rc libhello.a mymath.o myprint.o
mymath.o:mymath.c
gcc -c mymath.c -o mymath.o
myprint.o:myprint.c
gcc -c myprint.c -o myprint.o

.PHONY:output
output:
mkdir -p output/lib
mkdir -p output/include
cp -rf *.h output/include
cp -rf *.a output/lib
        cp -rf *.so output/lib

.PHONY:clean
clean:
rm -rf *.o *.a *.so output

make output 发布

mv uselib
打包

2.2.2 站在一个使用者（程序员）角度——使用动态库

链接：
前大i 后小L
gcc main.c -I output/include -L output/lib -lhello
gcc默认用的是动态库！
但是如果只有静态库，链接的时候就只能以静态方式链接

想要在有动态库的前提下，使用静态库：
gcc main.c -I output/include -L output/lib -lhello -static
-static的意义：摒弃默认优先使用动态库的原则，直接使用静态库

为什么使用动态库时可执行程序已经形成，但是一运行就报错？./a.out
程序是可执行的二进制程序
动态库是一个独立的库文件
动态库可以和可执行程序分批加载（静态库是同时加载）
（可以跳转到共享区）加载完可执行程序但是找不到动态库
之前所说的动态库的路径，是给gcc说的
运行加载的时候和gcc没有关系，需要再次像OS说明动态库路径

1.LD_LIBRARY_PATH
1：14:00
倒环境变量：

再次运行./a.out ldd a.out
就找到了
缺点：关闭终端之后，第二次登录之后，路径又不见了

2.修改配置文件
永久解决方案

sudo ldconfig更新

3.更简单的一种做法（但是不太推荐）
软链接方案

为什么要有库？

站在使用库的角度，库的存在，可以大大减少我们开发的周期，提高软件本身的质量。
站在写库的人的角度：简单，代码安全（逆向）

推荐两个好玩的库：
ncurses
boost