Linux文件系统管理、sehll命令(dd、fuser、)、压缩、归档、

Linux:

VFS:

Virtual FileSystem(虚拟文件系统)

对于系统来讲，一旦操作系统启动起来以后，最底层的是硬件，向上一次是内核，这段空间称为内核空间，能够跟硬件打交道的只能是内核，再向上是各自的应用程序，称之为进程，站在运行的角度来看，这些进程一旦需要跟硬件打交道，比如产生一些I/O操作的时候，这时候就必须要通过内核去申请，发起跟硬件交互操作，而这时对内核发起的操作通常都是systemcall（系统调用），内核的功能是通过一个一个接口，调用接口，通过这些systemcall来完成跟硬件进行交互的，所以说由于我们的磁盘本身就是个硬件，因此我们要使用磁盘空间，就需要进行系统调用，任何一个进程，比如mkdir这个命令，发起来的时候，它创建一个目录，很显然就需要在磁盘某个空间去创建一个目录，因此它就一定会产生系统调用的，跟内核申请要用磁盘，而内核这个时候就代替mkdir，就是它一定不会让mkdir自己去做这件事情，它要看mkdir到底申请的是什么，你要完成什么事情，而后由它代替mkdir去完成这个操作，因此操作系统的执行过程，这两段就分为两种模式，一般用户进程没有操作硬件的特权，所以这些进程它们所运行的模式称为用户模式，它们运行的空间叫做用户空间，所有的进程一般都运行在用户空间，指的就是它们没有特权，编程事实程序都在CPU上运行，而Intel或者AMD的CPU，这个CPU它一般有四种级别，自外而内有四个级别，称为四个环，这些环从内而外分别称为第0环、第1环、第2环和第3环，由于历史的原因，我们设计的程序的时候，这个环状结构决定了你能够在CPU上执行的指令，而CPU上的很多指令就是直接操作硬件设备的，比如发起一个I/O操作，在磁盘上建立一个文件等等，这是四个环，同心圆，最里面叫做环0，称为ring 0，一般来讲我们的内核是运行在ring 0上的，而我们的用户程序进程是运行在ring 3上的，ring 1和ring 2没有使用，而在第3级别下，它是没有执行特权的权限，任何程序在编程的时候，它无非就是利用了硬件芯片的额功能，而我们的CPU，AMD或者Intel x86系列的CPU，内置了就有很多指令，有些指令就是简单做一些获取信息或者打开文件之类的操作的，而有些指令直接是通过I/O调用直接操作外部硬件，它们就限定了有些特权指令，比如跟硬件打交道的指令，产生I/O操作的指令等等，都只能够在ring 0上运行，只有ring 0才有这种特权，而ring 3上没有任何特权，彼此之间交换可以，发个信号可以，但就是不能跟硬件打交道，不能跟外部设备打交道，跟外部设备打交道就意味着我要使用特权指令，而只要使用特权指令就必须ring 0才有权限的，内核是运行在ring 0上的，所以要想跟内核打交道，必须要转入内核才有这种权限，ring 3模式称为用户模式，或者说普通进程运行的空间，我们把它称为用户空间，而我们内核所运行的为位置，我们把它称为内核空间，也叫kernel space，或者内核模式，一个操作系统当中的文件系统是直接要管理磁盘分区上的文件存储方式的，也就是我在一个磁盘分区上到底应该怎么去存文件，它应该要存元数据和数据两种格式，元数据存在什么地方，数据存在什么地方，在数据区域要向存数据首先需要划分磁盘块，这些磁盘块怎么划分，这些都是由文件系统来管理的，因此文件系统必须跟硬件直接打交道的，如果说我们把文件系统放在用户空间的话，这势必会导致它的效率非常低，任何一个操作都要跟内核打交道，这是非常麻烦的，更何况本来管理文件就是内核应该具备的功能，所以文件系统是内核的功能，因此文件系统上对于任何一个文件操作都应该有文件系统的调用接口来实现，而事实一个内核本身所提供的功能都是通过系统调用来向外提供的，那因此管理文件的功能，文件系统的功能也是通过系统调用来提供的，只不过这些系统调用都跟文件操作相关，跟文件操作相关的系统调用有打开、关闭、创建、删除、写、读；打开和读是两码事，因此内核中的文件系统它也就通过所谓的系统调用，或者内核所提供的规范，把这接功能通过系统调用提供出去了，而系统调用是什么说白了，可以理解为函数，或者叫功能，或者叫功能调用接口，它本身是一个黑盒，它本身有这样的功能，但是它要把自己的功能提供出去，而且这些用户进程可以直接调用，可以通过这些调用接口来实现，但是，不同厂商或组织它们所开发的文件系统的可能是不一样的，它们彼此之间理解文件在磁盘分区中应该实现的组织方式是不同的，所以它们调用接口，甚至所提供的功能也可能是不尽相同的，这样以来任何一个用户空间的进程要想跟这样一个文件系统打交道，必须要能够直接调用它的功能，如果说两个文件系统所提供的功能不一样，调用接口的名称也不一样，调用的方法也不一样，作为上面的应用程序来讲，我们要想能够跟任何一种文件系统打交道，我们就必须要能够自我调用这任何一种文件系统的功能，所以这所有的难题都留给了应用程序的开发者，每个应用程序要想实现存储文件都要面对这多个不同类型的文件系统话，那将是非常困难的，而且大量的功能都是重复的，为了避免这种情况就出现了VFS（虚拟文件系统），VFS弥合了任何一种不同文件系统它们功能的不相同之处，而后以一个统一的风格向外将文件系统的调用接口输出，虚拟文件系统也是内核中的模块，因此VFS在内核中直接就将多种不同的文件系统的不同之处弥合了，对用户看来只需要调用虚拟文件系统提供的接口，对于说对应的磁盘是什么，将由虚拟文件系统完成转换工作，这就是VFS，也就是沙漏模型，对上面而言多个应用程序对下面而言多种文件系统，只有中间是一个VFS，对linux而言正是由于VFS的存在，使得它能够支持N种不同类型的文件系统；

文件系统：

ext3,ext4,ext2:extended扩展文件系统，红帽默认文件系统

reiserfs:suse默认文件系统

iso 9660(光盘),swap(交换文件系统),cifs(windows),nfs(unix)

xfs,jfs:unix文件系统

ocfs2,gfs2:集群文件系统

fat32,ntfs:windows文件系统

文件系统其实就是软件，只不过不同的文件系统它们管理文件的方式可能不尽相同

ext2文件系统管理：
对于任何一种文件系统它的数据都分为两类，一类是元数据，一类是数据，元数据是我们要存储文件的属性信息，比如文件名、大小等等，还有文件的路径，这种路径映射是通过目录，元数据区域说白了，我们要想打开磁盘上某个文件，首先要找元数据，因为只有元数据才标明了当前有没有这个文件，而且这个文件存储在什么地方，存储数据的空间很大，我们应该把数据放到什么地方，我怎么知道这个文件，比如里面存储了10w个文件，如何知道那个文件存储在什么位置，得首先将存储空间划分为block(块），划分成许许多多的block，这些称为磁盘块，或者称为文件系统块，这些块本身跟磁盘没有关系，是文件系统管理磁盘空间的逻辑结构，每一个块都有其编号，从0开始编号，从这个文件怎么知道一个文件在什么地方，在元数据区，每个文件都有其对应的元数据信息，这个文件是谁，以及这个文件存储在什么地方，它里面会有标识，存在第几个磁盘块上，一共占据了几个磁盘块它里面会有标识，比如说这里面有几个指针分别指向第3个、第8个、第16个磁盘块，于是我们要访问这个文件，我们系统会自动帮我们定位第3、第8、第16个磁盘块，一个磁盘块可属于多个文件，比如说找A文件的时候，找到第3号磁盘块，找B文件的时候，也找到第3号磁盘块，可以是同一个文件，路径不同，但内容相同，这种方式叫做硬链接，如果A和B的内容不一样，不能把它们存储在同一个磁盘块，所以一个磁盘块按道理内容只能属于一个文件，只不过可以有多个路径而已，这些路径称为硬连接，每一个标识信息叫做一个inode(index node),每一个文件基本都有它对应的inode,inode中要存储很多信息，文件的inode号、权限、属主属组、时间戳、文件大小，这些信息都应该存储在inode当中，所以每一个inode也会占据不小的空间，如果说要在文件系统上存储上百万个文件的话，意味着必须要给它预留上百万个inode空间，假如1个需要占用128个字节的话，一百万需要多少字节，事实占据的空间也相当不小，只要我们把一个分区格式化完以后，总会发现它少了很多空间，其实就是把那些区域划分出来用于实现存元数据了，无论用还是不用，都要事先给它划出来先放到那，磁盘分割在文件系统创建那一刻起把元数据区域空间就已经预留出来了，由此我们知道每一个磁盘块可能属于一个文件，而一个文件的inode也可能对应多个磁盘块，inode格式跟磁盘块个数并不是一一对应的， 假如一个磁盘分区上面有1000万个磁盘块，那我应该给他预留多少个inode,如果分区经常存储打文件，一个文件经常是上白个上千个磁盘块，只需要彼此间有个比例就可以了，要看存的文件多还是少，如果经常存大文件，而且每一个文件都很大，事实上inode少一点也没关系，如果说存的都是些零零碎碎的小文件，inode必须得足够才行，因此它们之间是有以后总比例关系的，比如说每多少个块给它创建一个inode,比如说每8k磁盘空间给它留一个Inode,8k应该是几个块，首先要明白块大小，对文件系统来讲块大小是确定的，它只能是2的N次方个字节，一般只能是1024、2048和4096这三种情况，到底有多少种情况，在不同的系统上可能不一样，在不同的CPU上可能不一样，因为磁盘的空间不能直接被CPU访问的，CPU要访问一个数据得首先把它装载进内存当中，所以我们要往内存中装载的话，不可能说这个块中的数据装一半进去，要么一个块全装进去，要么一下装几个块，所以内存中的空间一般分为叫页面的，内存中的空间是是存储叫页框的，一般一个页框只能放一个磁盘块、两个磁盘块或者四个块等等，页框大小通常是4k,所以如果是1k的块一次要装4个块进来，如果是2k的块一次装2块进来，但是这个页框的大小对于不同CPU平台来讲可能是不一样的，32位的和64位的所支持的页框大小都不一样，powerpc和x86平台的也是不一样的，各不相同，但不管怎么来讲块是有块大小的，我们到底使用1k的块好还是2k的块好还是4k的块好，看单个文件的大小，如果你有许许多多于1k的小文件小话，一个磁盘块只能属于一个文件，哪怕你这个文件里面只放了一个字符，占了一个字节而已，但是一个磁盘块都必须给它了，所以你要是4k磁盘块就浪费了，所以第一个文件一个字节，第二个文件一个字节，两个文件大小加起来是二个字节而已，但是两个文件占用的空间是，磁盘块如果是1k的话就是2k,这就是占据空间和实际文件大小的区别，在文件系统的辅助下要想在磁盘上创建一个文件的话，就意味着我们要有两个步骤去做，第一得给它个inode,第二给它找一个或多个磁盘块来存储其相关数据，也可能一个也没有，当我们存一个文件时候有可能遇到这样的情况，第一先创建inode,第二有可能得给它分配磁盘块，有些文件非常独特它不需要磁盘块，软链接、符号链接，但是如果符号连接的链接非常长的话在inode放不下有可能需要磁盘块，但是一般设备文件不会用磁盘块，所以设备文件没有大小，大小指的是占据磁盘块空间，它只用了inode没占磁盘块，所以它没有大小，像套接字文件、slockt文件、管道文件它们都没有大小的，因为套接字文件、管道文件、设备文件都可以把它们理解都是设备，当然设备又分为b设备和c设备，这也是为什么把它们称为特殊文件的原因，因此占据磁盘块的文件通常只有两类主流的，一类是普通文件，一类是目录文件；目录中存的到底是什么，文件名称和inode对应关系，对于一个磁盘分区来讲，如果空间很大，创建完以后，它的磁盘块的块数可能非常的多，而我们给它预留的Inode也非常的多，创建一个文件的时候，或者实现文件管理的时候，通常都要跟这些数据打交道，所以就以创建一个新文件为例，这个过程包括，我们得先找一个空闲的inode空间来存储对应的inode,其次要为这个inode所有存储的文件找一些空闲的磁盘块来存储数据，我们有这么多的空间来存储inode,比如预留了100w个inode,在这100w个存储空间里面，你到底那一个是空的，这1000w个块当中到底那一个是没使用的，可以拿来存数据的，怎么判断，如果没有额外的结构辅助的话，要想从所以的inode找空的出来，得遍历整个inode空间，每个inode都有标识，每个inode第一位，如果为0表示没使用，如果为1表示使用了，磁盘块也是，磁盘块第一个位可以理解标记位，0表示未使用，1表示使用了，遍历的方式去找这太困难了，遍历意味着要找一个空闲磁盘块要扫描整个分区，为了加速这两种方式引入了bitmap（位图），因此位图就有inode位图和块位图，inode位图就是用来标识inode,而块位图用来标识块的，每一个对应位图，一个位都跟对应所标识的结构是逐个对应的，所以扫描位图中为0的，挨位扫描，这速度要快的多，不用全盘扫描，只要发现这个为0就找到对应为0的磁盘块即可，磁盘管理并不是把整个分区作为一个组织来进行管理的，为了尽可能让它扫描这个位图对应的位足够小，而且扫描速度足够快，我们的系统事实上是首先要将我们的磁盘中的块划分成块组的，在分区基础上在划分一个逻辑区域，这个逻辑区域对用来来讲是透明的，而后对这些逻辑组逐个管理，每一个逻辑容器都有自己的inode表，有它的块位图，有它的inode位图，所以将来扫描一个块的时候它是每个组每个组来实现的，对文件来讲它是可以跨组的，对于扫描和管理按逐个组进行的，对一个分区来讲它有几个组，这取决于空间大小，一个组应该有多大，这取决于块位图和Inode位图的大小，一般来讲每一个位图都是使用一个磁盘块来进行标识的，一个块有多大，比如1k，1k有多少字节1024，一个字节有8位，1024*8这是它能标识的所有位，那就意味着一个位对应一个磁盘块，那它最多能容纳多少磁盘块就确定了，一个块位图它可能在元数据区域里面也使用一个块的大小来进行标识，而一个块假如是1k的块，1k有1024字节，每个字节8位，每一个位对应一个磁盘块，能对应1024*8个磁盘块，就意味着这一个块位图只能对应这么多块，而这么多块加起来只能逻辑组，一个块组里面只能有一个对应的位图，每一个块都与位图中的一个位相对应，很显然一个当中只能用了这么多位，就意味着我一个块组中只能有这么多块，所以一个快组中应该包含多少块是确定的，它还要取决你的块大小，这就决定了在不同磁盘分区上只要你的空间大小不一样，就意味着块总数可能不一样，所以对当前分区有多少块组，我们需要根据空间大小来确定，但是不能说每次来访问都确定一下，所以在创建文件系统的时候，一共创建了多少个块组，在元数据区域有个地方就保存下来了，这个东西叫做super block超级块，如果一个磁盘的超级块坏了，就意味着无法得知磁盘多少块组，每个快组当中有多少东西都无从得知，所以超级块坏了基本上整个分区就挂了，因此不能因为一个超级块坏了就殃及整个池鱼，可以有多个备份，超级块当中应该保存什么，它保存整个分区当中的全局信息包括，有多少块组、每个块组包含多少块、块大小、空闲磁盘块、已用磁盘块、空闲inode、已用inode等等；虽然已经知道它有多少快组，但是每个块组从那个块开始到那个块结束，我们也需要知道，假如我们有N个块，第一个快组从第1个块开始到第1000个块结束，第二个快组从1001个块开始到第2000个结束，我们整个文件系统本身元数据应该知道这些信息，怎么知道，超级块中没有记录，超级块只是一个块它记录不下来这么多信息，我们还有一个东西叫块组描述符表，这个里面保留有当前系统上一共有多少快组，每一个块组从第几个块开始到第几个块结束等相关信息都在这个所谓块组描述符表当中，如果这个表挂了文件系统也会挂的，所以也需要进行备份，而后每一个块组都有自己的inode表，这个组中给它预留了多少inode，每一个i额快组中也都有也有自己的块位图、inode位图，

Boot Block:不能够被使用，要预留出来，Boot Block是任何分区的第一个块，引导块，如果在这个分区装了操作系统，而这个操作系统的Bootload要装到这里面，多系统互存的时候会用到它，如果只用到一个操作系统Bootload是装在MBR当中的，如果装了两个操作系统，都有自己的Bootload当中，都需要撞到MBR当中，如果MBR被占据了，这个操作系统的Bootload可以放到这个分区的Boot Block当中

Block Group 0:块组，按照快组划分元数据区和数据区

Super Block:超级块，不是每个Block Group中都有，可能会备份3-4份，在特定编号的块组里面有，默认情况下找的一定是第0个Block Group中的Super Block，如果这个坏了，它会自动找下一个，一般来讲，如果不会，也可以使用命令手动从其他存放Super Block的位置复制一份过来就可以了，可以手动修复

GDT:块组描述符表，块组描述符表当中存放的是这当前分区上每一个块组的块组名、每一个快组起始磁盘块结束块的编号，所以这个信息也是不能损坏的，它也需要备份多次，根据你的块个数不同，它所占据的空间大小可能是不一样的，未必是一个磁盘块

操作系统如何查找文件内容：

要找到/var/log/message文件，先找根，根是自引用的，找到根的inode号，根据根的inode找到对应的磁盘块，在这些块里面存放有/var名称文件对应的Inode号，根据这个inode号再会过来查inode表，Inode表中找到/var目录所在的磁盘块，在这个磁盘块找到log文件所对应的Inode号，再回过来查inode表，又找到log的inode表，根据这个inode表再找log对应的磁盘块，根据这个块找到message这个文件名称所对应的inode号，再回到inode表查message对应的磁盘块，于是文件获取了，

/var/log/messages

目录中其实是一张表，它每张表每一行表示一个文件，每一行用来引用一个文件，而每一行的格式，首先inode号码、name_len(文件名称长度）、rec_len(最近一次访问）、file_type(文件类型)、文件名，这就是名称和inode号对应关系，因此我们找根以后，在根目录一定有对应一个叫/var的文件，/var的文件第一段就是var对应的inode号，根据这个inode号再回来查inode表，找到var对应的的磁盘块,再根据var找到log,再根据log找到messages,messages最终找到磁盘块，那它怎么引用磁盘块，任何一个inode它里面格式是这样的，首先inode号，接着往后是权限，属主属组、访问时间戳、更重要一段是这个文件的所存储的磁盘块的编号，也可以理解为指针，那它怎么去编号的，这个空间也是有限的，比如存到第0号磁盘块、第3号磁盘块、第10号磁盘块，如果我存储了100个磁盘块，就意味着这100个磁盘块编号都得写到这，空间有限，如果占据1w个磁盘块，1w个编号写到这需要多大空间，很困难，那如何实现

可以使用逐层格式来进行调用，叫一级间接指针、二级间接指针和直接指针，一级磁盘块指针一般只能指向10来个磁盘块，一般来讲文件大小超出1M就得使用间接指针，超出1G或2G可能就需要二级间接指针，所以不管能有多少级，这些指针加起来它所能引用指向块的个数总然是有限的，这个有限的最大限，就是单个文件的最大大小的限定，比如所有磁盘块指针全用起来，最多能够指向100W个块，而这100W块，1个块大小是4K,那这也就是400WK

Mode:权限

Ownoer info:属主属组

Size:大小

Timestamps:时间戳

Direct Blocks:直接磁盘块指针

Indirect blocks:间接磁盘块指针

Donble Indirect:二级间接磁盘块指针

Triple Indirect:三级间接磁盘块指针

block size: 1024bytes(1k)、2048bytes(2k)、4096bytes(4k)这三种情况

ext2文件系统和ext3文件系统区别：

ext2和ext3的的最大区别在于，ext3被称为叫journal file system(日志文件系统)，任何时候创建一个文件要创建一个文件的元数据，然后给它分配固定的空闲磁盘块，而把这些文件一点一点给它存储进来就可以了，比如存储一个文件，上来给你建一个Inode，上来给你分配8个空闲块，于是开始存储数据，当存储8个发现8个不够用，再申请8个继续存，再不够，再申请，不是一下分给你的，如果分配了8个，只用了1个，其他剩余的释放就可以了，如果存一个文件比较大，它需要占据100个块，于是需要先建立inode，给它申请8个块，我已经填满98个块，还剩下2个块就填满了，突然系统断电了，文件存储不完整，打开文件不能用，开机以后ext2需要查找存储不完整的文件，速度非常慢，进行删除，修复速度非常的慢，那怎么办，日志就起了作用，日志它是磁盘空间第三个独立区域，分区本来就分成数据区和元数据区，有了日志，磁盘就分成了三个区，数据区、源数据区、日志区，我们为了存一个文件是这样存的，要先存inode再存数据到数据区，这样不是这样，把inode放到日志区创建，没有创建在源数据区，创建好inode以后，接下来开始存数据，如果数据存到一半断电了，不需要检查别的，只需要检测日志区就行了，因为那些没有来得及存完的文件，甚至包括你正在修改的文件，那个文件修改了把这个文件inode先挪到日至区域，所以需要检测日志区域有那几个文件，去修复这几个文件就可以了，如果数据正常存放没断电，把这个数据的inode从日志区再放回元数据区，所以真正数据存完了，把inode挪到元数据区域，大大缩减了开机要完成文件系统检查的速度，但是写要多一次，多一次I/O操作，又得是把元数据和数据都放到日志区域，存好之后再放到元数据区和数据区域，但是有时候ext3比ext2要慢一些，尤其写的操作，读没有影响

文件系统的管理操作：

1、文件系统大小

2、超级块在什么位置，超级块备份个数够不够

3、GDT在什么位置，备份数够不够，里面存了那些信息，分了多少个磁盘块，有没有产生磁盘碎片，需要不需要修复，

4、一共有多少块组，那些块组有碎片等等

5、新加磁盘进来，分区、格式化、挂载

创建分区命令:

fdisk：分区管理

-l：查看分区使用情况

m：查看帮助

p：查看分区信息

n: 创建新分区

d: 删除分区

w: 保存退出

q: 不保存退出

l: 查看分区类型信息

t: 调整分区类型

cat /proc/partitons：查看内核识别的分区

partprobe [/dev/sda]:让内核重新加载分区表

partx -a:redhat 6.x让内核重新加载分区表，，-a添加指定分区或磁盘读取并添加所有分区）

文件系统管理

格式化分区：不能在已有的文件的分区创建文件系统，重新创建文件系统会损坏原有文件，因为它重新划分整个文件组织结构并假设里面空无一个文件，所以不要对已有数据的分区创建文件系统

mkfs: make file system创建文件系统

　　-t FSTYPE：指定文件系统类型

mkfs -t ext2 = mkfs.ext2：mkfs是统一调用格式化命令接口，任何当前内核所支持的文件系统都可以mkfs -t的方式来指定其文件系统类型

mkfs -t ext3 = mkfs.ext3

partx -a /dev/sda：REDHAT 6.X版本让内核重新加载sda设备命令，-a添加指定分区或磁盘读取并添加所有分区

文件系统是有类型的，当前内核支持那些类型文件系统，不是随便可以创建的，虽然说linux的VFS支持众多的文件系统，但是你当前内核未必支持，说支持是内核具有这种功能，不支持意思是这种功能是有开关的，也就意味着我们在把内核从源代码编译成二进制的时候，如果把这个功能给它去了，它就不支持了，所以当前这个内核到底支持那些种文件系统，可能跟你想象的未必完全一样，只有内核中具有这种文件系统的模块，它才能支持，而这种模块在linux源码中几乎大多数提到的都支持，只不过编译内核的时候没选择把它编译进来，那就不具备这种功能

cat /proc/filesystems：查看当前系统支持那些文件系统

专门管理ext系列文件：

mke2fs

　　-j: 创建ext3类型文件系统

　　-b BLOCK_SIZE: 指定块大小，默认为4096；可用取值为1024、2048或4096；

　　-L LABEL：指定分区卷标；可以直接使用卷标引用分区

　　-m #: 指定预留给超级用户的块数百分比，默认预留百分之五；

　　-i #: 用于指定为多少字节的空间创建一个inode，默认为8192(8K)；这里给出的数值应该为块大小的2^n倍；

　　-N #: 手工指定具体inode个数；

　　-F: 强制创建文件系统；如果文件系统被挂载不允许创建，可以使用强制创建

　　-E: 用户指定额外文件系统属性;

blkid: 查询或查看磁盘设备的相关属性

　　UUID：统一全局标识符，操作系统随机生成用于唯一标识磁盘设备

　　TYPE：文件系统类型

　　LABEL：卷标

e2label: 用于查看或定义卷标

　　e2label 设备文件 卷标: 设定卷标

tune2fs: 调整文件系统的相关属性

　　-j: 不损害原有数据，将ext2升级为ext3；

　　-L LABEL: 设定或修改卷标;

　　-m #: 调整预留给超级管理员磁盘块百分比，默认预留百分之五；

　　-r #: 指定预留给超级管理员磁盘块数量；

　　-o: 设定默认挂载选项；

　　　　acl：开启挂载分区支持acl功能

　　-c #：指定挂载次数达到#次之后进行自检，0或-1表关闭此功能；

　　-i #: 每挂载使用多少天后进行自检；0或-1表示关闭此功能；

　　-l: 显示超级块中的信息；

块大小属性是物理属性，不能通过命令修改，要修改必须重新格式化文件系统；

dumpe2fs: 显示文件属性信息

　　-h: 只显示超级块中的信息

fsck: 检查并修复Linux文件系统，支持所有文件系统修复

　　-t FSTYPE: 指定文件系统类型，不能将类型指错，指错会出现问题

　　-a: 自动修复，不指定会弹出询问信息

e2fsck: 专用于修复ext2/ext3文件系统

　　-f: 强制检查，没问题也检查

　　-p: 自动修复；

　　-a: 自动修复，不指定会弹出询问信息

mkfs.ext4：创建ext4的文件系统

挂载：将新的文件系统关联至当前根文件系统

卸载：将某文件系统与当前根文件系统的关联关系预以移除；

mount：挂载

mount 设备 挂载点

　　设备：指定设备

　　　　设备文件：/dev/sda5

　　　　卷标：LABEL=""

　　　　UUID： UUID=""

　　挂载点：目录

　　　　要求：

　　　　　　1、此目录没有被其它进程使用；

　　　　　　2、目录得事先存在；

　　　　　　3、目录中的原有的文件将会暂时隐藏；

mount: 显示当前系统已经挂载的设备及挂载点

mount [options] [-o options] DEVICE MOUNT_POINT：[options]是mount命令选项，选项[-o options]指的是挂载文件系统时候，挂载文件系统的功能选项；

　　-a: 表示挂载/etc/fstab文件中定义的所有文件系统

　　-n: 默认情况下，mount命令每挂载一个设备，都会把挂载的设备信息保存至/etc/mtab文件；mount命令显示的就是/etc/mtab文件中的内容，使用-n选项意味着挂载设备时，不把信息写入此文件；

　　-t FSTYPE: 指定正在挂载设备上的文件系统的类型；不使用此选项时，mount会调用blkid命令获取对应文件系统的类型；

　　-r: 只读挂载，挂载光盘时常用此选项，对写保护和只读的设备不会提示警告

　　-w: 读写挂载，默认是读写挂载，光盘是只读挂载

　　-o: 指定额外的挂载选项，也即指定文件系统启用的属性，大部分选项都可以使用no option进行关闭此功能，如果指定多个功能属性，选项之间通过,逗号隔开即可；

　　　　remount: 重新挂载当前文件系统，把卸载和挂载一块来使用，先卸载再挂载，重新挂载可以不指定挂载点；

　　　　ro: 挂载为只读

　　　　rw: 读写挂载

　　　　async：异步写入，当视图在进程保存一个文件，先保存到内存中，过一段时间才再保存到磁盘

　　　　atime：文件每访问一次都把它最近访问时间更新下，但是每次更新都会产生磁盘I/O的，一个磁盘I/O都会大量影响你的系统性能的，所以有些情况下我们完全可以把它的atime给它关掉，如果写atime就是每次访问都要更新，如果不更新no atime即可；

　　　　auto：表示这个磁盘设备可不可以能使用-a选项自动挂载

　　　　defaults：如果没指挂载选项，就使用默认选项：rw,suid,dev,exec,nouser,async选项

　　　　dev：如果当前这个文件系统上有其他设备的设备文件是否启用它们，是否可以把它们作为其他设备访问入口，dev表示允许启用；

　　　　exec：允许这个上具有可执行权限的文件运行起来；挂载U盘可以使用no exec防止自动执行的病毒；

　　　　netdev：如果挂载的设备它是一个映射到其他主机的文件系统，一个网络文件系统的话，如果网络不可用，那台主机访问不到，就不再挂载那台设备，如果设备开机自动挂载网络上的文件系统，不使用netdev选项，如果被挂载的那台主机的文件系统访问不到，就会导致开机卡在那里，系统无法启动；

　　　　owner：允许普通用户挂载这个文件系统；

　　　　sync：同步写入；

　　　　suid：如果某个文件被置为suid选项功能，那么要启用这种功能，suid是一种不安全做法，可以no suid选项；

　　　　loop：挂载本地回环设备，常用于挂载iso文件；

 

CPU操作的数据都是内存，直接在内存中完成数据，所以读一个文件，CPU要试图加载一个文件数据的时候，如果数据没有在内存中，此时就会产生I/O请求，先把文件从硬盘加载至内存的一个指定区域里面，然后CPU上的进程才能访问，同样写操作，如果这个进程需要把这个文件数据改一改并保存下来，它在内存中保存，如果保存到内存中万一系统断电了，内存是易失性的，这个数据会损失，为了不损失将数据写到硬盘上去，像这种先保存到内存当中，过一段时间才保存到真正目的地硬盘上，这种模式叫异步的，它没有直接就保存到硬盘上去，所以称为异步；数据在保存至所谓的，虽然是在内存中编辑的，但只要在内存一保存，这个数据立即得先保存磁盘上去，对于同步数据安全的多，缺陷：硬盘比CPU和内存都慢的多，会导致系统性能极低的，所以一般情况下磁盘使用都是异步的，尤其是写入操作；
挂载完成后，要通过挂载点访问对应文件系统上的文件；

umount: 卸载某文件系统

　　-r：若无法成功卸除，则尝试以只读的方式重新挂入文件系统；

　　-a：卸载所有/etc/fstab文件中定义的文件系统；

　　umount 设备

　　umount 挂载点

　　卸载注意事项：

　　　　挂载的设备没有进程使用；

[root@Smoke ~]# fdisk -l（查看当前系统所有磁盘及分区）
Disk /dev/sda: 42.9 GB, 42949672960 bytes
255 heads, 63 sectors/track, 5221 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00031216
  Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1          26      204800   83  Linux
Partition 1 does not end on cylinder boundary.
/dev/sda2              26        2576    20480000   83  Linux
/dev/sda3            2576        2706     1048576   82  Linux swap / Solaris
[root@Smoke ~]# fdisk /dev/sda（管理磁盘分区，进入交互式）
WARNING: DOS-compatible mode is deprecated. It's strongly recommended to
        switch off the mode (command 'c') and change display units to
        sectors (command 'u').
Command (m for help): p（显示当前磁盘的分区）
Disk /dev/sda: 42.9 GB, 42949672960 bytes
255 heads, 63 sectors/track, 5221 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00031216
  Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1          26      204800   83  Linux
Partition 1 does not end on cylinder boundary.
/dev/sda2              26        2576    20480000   83  Linux
/dev/sda3            2576        2706     1048576   82  Linux swap / Solaris
Command (m for help): n（创建新的分区）
Command action
  e   extended
  p   primary partition (1-4)
e（扩展分区）
Selected partition 4（选择分区编号，总共有4个主分区，编号为1-4，如果前面的编号都被使用，自动选择4）
First cylinder (2706-5221, default 2706):
Using default value 2706
Last cylinder, +cylinders or +size{K,M,G} (2706-5221, default 5221):
Using default value 5221
Command (m for help): n（创建逻辑分区）
First cylinder (2706-5221, default 2706):
Using default value 2706
Last cylinder, +cylinders or +size{K,M,G} (2706-5221, default 5221): +2G（创建2G逻辑分区）
Command (m for help): n（创建逻辑分区）
First cylinder (2968-5221, default 2968):
Using default value 2968
Last cylinder, +cylinders or +size{K,M,G} (2968-5221, default 5221): +5G（创建5G逻辑分区）
Command (m for help): n（创建逻辑分区）
First cylinder (3622-5221, default 3622):
Using default value 3622
Last cylinder, +cylinders or +size{K,M,G} (3622-5221, default 5221): +1G（创建1G逻辑分区）
Command (m for help): p（显示当前磁盘的分区）
Disk /dev/sda: 42.9 GB, 42949672960 bytes
255 heads, 63 sectors/track, 5221 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00031216
  Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1          26      204800   83  Linux
Partition 1 does not end on cylinder boundary.
/dev/sda2              26        2576    20480000   83  Linux
/dev/sda3            2576        2706     1048576   82  Linux swap / Solaris
/dev/sda4            2706        5221    20203282+   5  Extended
/dev/sda5            2706        2967     2097996   83  Linux
/dev/sda6            2968        3621     5253223+  83  Linux
/dev/sda7            3622        3753     1060258+  83  Linux
Command (m for help): w（保存退出）
The partition table has been altered!
Calling ioctl() to re-read partition table.
WARNING: Re-reading the partition table failed with error 16: Device or resource busy.
The kernel still uses the old table. The new table will be used at
the next reboot or after you run partprobe(8) or kpartx(8)
Syncing disks.
[root@Smoke ~]# cat /proc/partitions（查看内核识别的分区）
major minor  #blocks  name
  8        0   41943040 sda
  8        1     204800 sda1
  8        2   20480000 sda2
  8        3    1048576 sda3
[root@Smoke ~]# partprobe /dev/sda（让内核重新加载sda分区表）
[root@Smoke ~]# partx -a /dev/sda（REDHAT 6.X版本让内核重新加载sda设备命令，-a添加指定分区或磁盘读取并添加所有分区）
# 1:      2048-   411647 (   409600 sectors,    209 MB)
# 2:    411648- 41371647 ( 40960000 sectors,  20971 MB)
# 3:  41371648- 43468799 (  2097152 sectors,   1073 MB)
# 4:  43468800- 83875364 ( 40406565 sectors,  20688 MB)
# 5:  43468863- 47664854 (  4195992 sectors,   2148 MB)
# 6:  47664918- 58171364 ( 10506447 sectors,   5379 MB)
# 7:  58171428- 60291944 (  2120517 sectors,   1085 MB)
[root@Smoke ~]# cat /proc/partitions（查看内核识别的分区）
major minor  #blocks  name
  8        0   41943040 sda
  8        1     204800 sda1
  8        2   20480000 sda2
  8        3    1048576 sda3
  8        4          1 sda4
  8        5    2097996 sda5
  8        6    5253223 sda6
  8        7    1060258 sda7
[root@Smoke ~]# cat /proc/filesystems（查看当前系统支持那些文件系统）
nodev        sysfs
nodev        rootfs
nodev        bdev
nodev        proc
nodev        cgroup
nodev        cpuset
nodev        tmpfs
nodev        devtmpfs
nodev        binfmt_misc
nodev        debugfs
nodev        securityfs
nodev        sockfs
nodev        usbfs
nodev        pipefs
nodev        anon_inodefs
nodev        inotifyfs
nodev        devpts
nodev        ramfs
nodev        hugetlbfs
       iso9660
nodev        pstore
nodev        mqueue
       ext4
nodev        fuse
       fuseblk
nodev        fusectl
nodev        rpc_pipefs
nodev        autofs
nodev        nfsd
[root@Smoke ~]# mkfs -t ext2 /dev/sda5（将分区sda5创建成ext2类型的文件系统）
mke2fs 1.41.12 (17-May-2010)
warning: 211 blocks unused.
Filesystem label=（文件系统卷标）
OS type: Linux（操作系统类型）
Block size=4096 (log=2)（块大小4096bytes）
Fragment size=4096 (log=2)（偏移大小）
Stride=0 blocks, Stripe width=0 blocks
131328 inodes,（inode数量） 524288 blocks（块数量）
26224 blocks (5.00%) reserved for the super user（有26224个块，大约占用总块数524288的5%预留给超级管理员使用，
一般情况下当我们在一个分区上创建文件系统的时候，它会把这个分区里面5%的磁盘块空间预留给超级管理员，一旦当这个分区被填满之后，
我们管理员进来做一些修复工作的时候，还有多余的空间可用，可以自己指定预留百分比）
First data block=0（第一个数据块）
Maximum filesystem blocks=536870912（最大文件系统块多少）
16 block groups（多少个块组）
32768 blocks per group,（每个块组有多少块） 32768 fragments per group（每个组有多少片，片可以理解成块）
8208 inodes per group（每隔组有多少inode）
Superblock backups stored on blocks:（Superblock超级块备份在那些磁盘块）
       32768, 98304, 163840, 229376, 294912
Writing inode tables: done （正在写inode tables，done完成）                          
Writing superblocks and filesystem accounting information: done（正在写superblocks和文件系统统计信息，done完成）
This filesystem will be automatically checked every 36 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.（这个文件系统可以被挂载使用，每挂载36次或使用超过180天了，要做一次检测，可以使用tune2fs 
-c或-i修改）
[root@Smoke ~]# mkfs -t ext3 /dev/sda7（将sda7分区创建为ext3类型的文件系统）
mke2fs 1.41.12 (17-May-2010)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
66384 inodes, 265064 blocks
13253 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=272629760
9 block groups
32768 blocks per group, 32768 fragments per group
7376 inodes per group
Superblock backups stored on blocks:
       32768, 98304, 163840, 229376
Writing inode tables: done                            
Creating journal (8192 blocks): done（正在创建日志数据区域，done完成）
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 21 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.
[root@Smoke ~]# which mkfs（查看mkfs文件的路径）
/sbin/mkfs
[root@Smoke ~]# ls -l /sbin/mkfs（查看mkfs文件详细信息）
-rwxr-xr-x. 1 root root 10336 Nov 22  2013 /sbin/mkfs
[root@Smoke ~]# mkfs.（输入mkfs.点击tab查看mkfs.开头的命令）
mkfs.cramfs   mkfs.ext2     mkfs.ext3     mkfs.ext4     mkfs.ext4dev  mkfs.msdos    mkfs.vfat
[root@Smoke ~]# which mkfs.ext2（查看mkfs.ext2文件路径）
/sbin/mkfs.ext2
[root@Smoke ~]# ls -l /sbin/mkfs.ext2
-rwxr-xr-x. 5 root root 68960 Nov 22  2013 /sbin/mkfs.ext2
[root@Smoke ~]# mkfs.vfat /dev/sda6（将sda6分区创建为vfat类型的windows文件系统fat32）
mkfs.vfat 3.0.9 (31 Jan 2010)
[root@Smoke ~]# mke2fs /dev/sda5（将sda5分区创建为ext2类型的文件系统）
mke2fs 1.41.12 (17-May-2010)
warning: 211 blocks unused.
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
131328 inodes, 524288 blocks
26224 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=536870912
16 block groups
32768 blocks per group, 32768 fragments per group
8208 inodes per group
Superblock backups stored on blocks:
       32768, 98304, 163840, 229376, 294912
Writing inode tables: done                            
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 28 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.
[root@Smoke ~]# mke2fs -j /dev/sda5（将分区sda5创建为ext3类型文件系统，-j创建为ext3文件系统）
mke2fs 1.41.12 (17-May-2010)
warning: 211 blocks unused.
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
131328 inodes, 524288 blocks
26224 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=536870912
16 block groups
32768 blocks per group, 32768 fragments per group
8208 inodes per group
Superblock backups stored on blocks:
       32768, 98304, 163840, 229376, 294912
Writing inode tables: done                            
Creating journal (16384 blocks): done
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 37 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.
[root@Smoke ~]# mke2fs -b 2048 /dev/sda5（将分区sda5创建为ext2类型文件系统，并指定磁盘块大小为2048)
mke2fs 1.41.12 (17-May-2010)
Filesystem label=
OS type: Linux
Block size=2048 (log=1)
Fragment size=2048 (log=1)
Stride=0 blocks, Stripe width=0 blocks
131560 inodes, 1048998 blocks
52449 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=538968064
65 block groups
16384 blocks per group, 16384 fragments per group
2024 inodes per group
Superblock backups stored on blocks:
       16384, 49152, 81920, 114688, 147456, 409600, 442368, 802816
Writing inode tables: done                            
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 28 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.
[root@Smoke ~]# mke2fs -L MYDATA /dev/sda5（将分区sda5创建为ext2类型文件系统，并通过-L指定卷标为MYDATA)
mke2fs 1.41.12 (17-May-2010)
warning: 211 blocks unused.
Filesystem label=MYDATA
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
131328 inodes, 524288 blocks
26224 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=536870912
16 block groups
32768 blocks per group, 32768 fragments per group
8208 inodes per group
Superblock backups stored on blocks:
       32768, 98304, 163840, 229376, 294912
Writing inode tables: done                            
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 31 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.
[root@Smoke ~]# mke2fs -m 3 /dev/sda5（将分区sda5创建为ext2类型文件系统，并通过-m指定预留给超级用户的磁盘块百分比为3%）
mke2fs 1.41.12 (17-May-2010)
warning: 211 blocks unused.
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
131328 inodes, 524288 blocks
15734 blocks (3.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=536870912
16 block groups
32768 blocks per group, 32768 fragments per group
8208 inodes per group
Superblock backups stored on blocks:
       32768, 98304, 163840, 229376, 294912
Writing inode tables: done                            
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 27 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.
[root@Smoke ~]# mke2fs -i 4096 /dev/sda5（将分区sda5创建为ext2类型文件系统，通过-i指定4096bytes大小创建1个inode）
mke2fs 1.41.12 (17-May-2010)
Filesystem label=
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
524688 inodes, 524499 blocks
26224 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=539215872
17 block groups
32656 blocks per group, 32656 fragments per group
30864 inodes per group
Superblock backups stored on blocks:
       32656, 97968, 163280, 228592, 293904
Writing inode tables: done                            
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 22 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.
[root@Smoke ~]# blkid /dev/sda5（查看磁盘sda5设备的相关属性，可以查看文件系统UUID、文件系统类型、卷标）
/dev/sda5: UUID="b0b094c6-0660-4e62-ace5-86564ebaffa6" TYPE="ext2"
[root@Smoke ~]# blkid /dev/sda7（查看磁盘sda7设备相关属性，可以查看文件系统UUID、文件系统类型、卷标）
/dev/sda7: UUID="8e98bf87-d09e-46e4-b9fe-1502c596d7d5" SEC_TYPE="ext2"（安全类型） TYPE="ext3"（真正类型）
[root@Smoke ~]# blkid /dev/sda6（查看磁盘sda6设备相关属性，可以查看文件系统UUID、文件系统类型、卷标）
/dev/sda6: UUID="CDE2-FE6C" TYPE="vfat"
[root@Smoke ~]# mke2fs -L MYDATA /dev/sda5（将分区sda5创建为ext2类型文件系统，并通过-L指定卷标为MYDATA）
mke2fs 1.41.12 (17-May-2010)
warning: 211 blocks unused.
Filesystem label=MYDATA
OS type: Linux
Block size=4096 (log=2)
Fragment size=4096 (log=2)
Stride=0 blocks, Stripe width=0 blocks
131328 inodes, 524288 blocks
26224 blocks (5.00%) reserved for the super user
First data block=0
Maximum filesystem blocks=536870912
16 block groups
32768 blocks per group, 32768 fragments per group
8208 inodes per group
Superblock backups stored on blocks:
       32768, 98304, 163840, 229376, 294912
Writing inode tables: done                            
Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 21 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.
[root@Smoke ~]# blkid /dev/sda5（查看磁盘sda5设备相关属性，可以查看文件系统UUID、文件系统类型、卷标）
/dev/sda5: UUID="e62edf22-b493-4c86-8b6c-6092c6e26c82" TYPE="ext2" LABEL="MYDATA"
[root@Smoke ~]# e2label /dev/sda5（查看分区sda5设备的卷标）
MYDATA
[root@Smoke ~]# e2label /dev/sda5 HELLODATA（修改分区sda5设备卷标为HELLODATA）
[root@Smoke ~]# e2label /dev/sda5（查看分区sda5设备卷标）
HELLODATA
[root@Smoke ~]# tune2fs -j /dev/sda5（将分区sda5设备类型ext2升级为ext3类型文件系统，-j不损害原有数据，将ext2升级为ext3）
tune2fs 1.41.12 (17-May-2010)
Creating journal inode: done
This filesystem will be automatically checked every 21 mounts or
180 days, whichever comes first.  Use tune2fs -c or -i to override.
[root@Smoke ~]# blkid /dev/sda5（查看分区sda5设备相关属性，可以查看UUID、文件系统类型、卷标；文件系统类型变为ext3类型文件系统）
/dev/sda5: LABEL="HELLODATA" UUID="e62edf22-b493-4c86-8b6c-6092c6e26c82" SEC_TYPE="ext2" TYPE="ext3"
[root@Smoke ~]# tune2fs -L MYDATA /dev/sda5（更改分区sda5设备卷标为MYDATA，-L更改文件系统卷标）
[root@Smoke ~]# blkid /dev/sda5（查看分区sda5设备相关属性，可以查看文件系统UUID、文件系统类型、卷标；卷标更改为MYDATA）
/dev/sda5: LABEL="MYDATA" UUID="e62edf22-b493-4c86-8b6c-6092c6e26c82" SEC_TYPE="ext2" TYPE="ext3"
[root@Smoke ~]# tune2fs -l /dev/sda5（显示分区sda5设备显示超级块中的信息）
tune2fs 1.41.12 (17-May-2010)
Filesystem volume name:   MYDATA（卷标）
Last mounted on:          <not available>（最近什么时候挂载过）
Filesystem UUID:          e62edf22-b493-4c86-8b6c-6092c6e26c82（UUID）
Filesystem magic number:  0xEF53（文件系统类型的magic number）
Filesystem revision #:    1 (dynamic)
Filesystem features:      has_journal（日志） ext_attr resize_inode（inode重新调整） dir_index（目录索引） filetype（文件系统类型） 
sparse_super large_file（具有那些功能）
Filesystem flags:         signed_directory_hash
Default mount options:    (none)
Filesystem state:         clean（文件系统状态，clean不用自检不用修复，date表示有修复自检的文件）
Errors behavior:          Continue
Filesystem OS type:       Linux
Inode count:              131328（inode个数）
Block count:              524288（block个数）
Reserved block count:     26224
Free blocks:              498867（空闲blocks)
Free inodes:              131317（空闲inodes）
First block:              0
Block size:               4096（block大小）
Fragment size:            4096
Reserved GDT blocks:      127
Blocks per group:         32768
Fragments per group:      32768
Inodes per group:         8208
Inode blocks per group:   513
Filesystem created:       Tue Jul 15 23:05:18 2014
Last mount time:          n/a（上次挂载时间）
Last write time:          Tue Jul 15 23:20:25 2014（上次写入时间）
Mount count:              0（挂载次数）
Maximum mount count:      21（最大挂载多少次开始自检）
Last checked:             Tue Jul 15 23:05:18 2014（上次什么时候检查的）
Check interval:           15552000 (6 months)（检查时间间隔）
Next check after:         Sun Jan 11 23:05:18 2015（下次检查规定什么时间）
Reserved blocks uid:      0 (user root)
Reserved blocks gid:      0 (group root)
First inode:              11
Inode size:                  256（inode大小）
Required extra isize:     28
Desired extra isize:      28
Journal inode:            8
Default directory hash:   half_md4
Directory Hash Seed:      f5c69b69-55ff-46dd-942f-5882749b50fd
Journal backup:           inode blocks
[root@Smoke ~]# dumpe2fs /dev/sda5（显示分区sda5设备文件属性信息）
dumpe2fs 1.41.12 (17-May-2010)
Filesystem volume name:   MYDATA
Last mounted on:          <not available>
Filesystem UUID:          e62edf22-b493-4c86-8b6c-6092c6e26c82
Filesystem magic number:  0xEF53
Filesystem revision #:    1 (dynamic)
Filesystem features:      has_journal ext_attr resize_inode dir_index filetype sparse_super large_file
Filesystem flags:         signed_directory_hash
Default mount options:    (none)
Filesystem state:         clean
Errors behavior:          Continue
Filesystem OS type:       Linux
Inode count:              131328
Block count:              524288
Reserved block count:     26224
Free blocks:              498867
Free inodes:              131317
First block:              0
Block size:               4096
Fragment size:            4096
Reserved GDT blocks:      127
Blocks per group:         32768
Fragments per group:      32768
Inodes per group:         8208
Inode blocks per group:   513
Filesystem created:       Tue Jul 15 23:05:18 2014
Last mount time:          n/a
Last write time:          Tue Jul 15 23:20:25 2014
Mount count:              0
Maximum mount count:      21
Last checked:             Tue Jul 15 23:05:18 2014
Check interval:           15552000 (6 months)
Next check after:         Sun Jan 11 23:05:18 2015
Reserved blocks uid:      0 (user root)
Reserved blocks gid:      0 (group root)
First inode:              11
Inode size:                  256
Required extra isize:     28
Desired extra isize:      28
Journal inode:            8
Default directory hash:   half_md4
Directory Hash Seed:      f5c69b69-55ff-46dd-942f-5882749b50fd
Journal backup:           inode blocks
Journal features:         (none)
Journal size:             64M
Journal length:           16384
Journal sequence:         0x00000001
Journal start:            0
Group 0: (Blocks 0-32767)
 Primary superblock at 0,（主超级块，超级块默认使用快组0）Group descriptors at 1-1
 Reserved GDT blocks at 2-128
 Block bitmap at 129 (+129), Inode bitmap at 130 (+130)
 Inode table at 131-643 (+131)
 32118 free blocks, 8197 free inodes, 2 directories
 Free blocks: 650-32767（空闲块）
 Free inodes: 12-8208
Group 1: (Blocks 32768-65535)
 Backup superblock at 32768,（超级块备份） Group descriptors at 32769-32769
 Reserved GDT blocks at 32770-32896
 Block bitmap at 32897 (+129), Inode bitmap at 32898 (+130)
 Inode table at 32899-33411 (+131)
 32124 free blocks, 8208 free inodes, 0 directories
 Free blocks: 33412-65535
 Free inodes: 8209-16416
Group 2: (Blocks 65536-98303)
 Block bitmap at 65536 (+0), Inode bitmap at 65537 (+1)
 Inode table at 65538-66050 (+2)
 32253 free blocks, 8208 free inodes, 0 directories
 Free blocks: 66051-98303
 Free inodes: 16417-24624
Group 3: (Blocks 98304-131071)
 Backup superblock at 98304,（超级块备份）Group descriptors at 98305-98305
 Reserved GDT blocks at 98306-98432
 Block bitmap at 98433 (+129), Inode bitmap at 98434 (+130)
 Inode table at 98435-98947 (+131)
 32124 free blocks, 8208 free inodes, 0 directories
 Free blocks: 98948-131071
 Free inodes: 24625-32832
Group 4: (Blocks 131072-163839)
 Block bitmap at 131072 (+0), Inode bitmap at 131073 (+1)
 Inode table at 131074-131586 (+2)
 32253 free blocks, 8208 free inodes, 0 directories
 Free blocks: 131587-163839
 Free inodes: 32833-41040
Group 5: (Blocks 163840-196607)
 Backup superblock at 163840,（超级块备份） Group descriptors at 163841-163841
 Reserved GDT blocks at 163842-163968
 Block bitmap at 163969 (+129), Inode bitmap at 163970 (+130)
 Inode table at 163971-164483 (+131)
 32124 free blocks, 8208 free inodes, 0 directories
 Free blocks: 164484-196607
 Free inodes: 41041-49248
Group 6: (Blocks 196608-229375)
 Block bitmap at 196608 (+0), Inode bitmap at 196609 (+1)
 Inode table at 196610-197122 (+2)
 32253 free blocks, 8208 free inodes, 0 directories
 Free blocks: 197123-229375
 Free inodes: 49249-57456
Group 7: (Blocks 229376-262143)
 Backup superblock at 229376,（超级块备份） Group descriptors at 229377-229377
 Reserved GDT blocks at 229378-229504
 Block bitmap at 229505 (+129), Inode bitmap at 229506 (+130)
 Inode table at 229507-230019 (+131)
 32124 free blocks, 8208 free inodes, 0 directories
 Free blocks: 230020-262143
 Free inodes: 57457-65664
Group 8: (Blocks 262144-294911)
 Block bitmap at 262144 (+0), Inode bitmap at 262145 (+1)
 Inode table at 262146-262658 (+2)
 15852 free blocks, 8208 free inodes, 0 directories
 Free blocks: 279060-294911
 Free inodes: 65665-73872
Group 9: (Blocks 294912-327679)
 Backup superblock at 294912,（超级块备份） Group descriptors at 294913-294913
 Reserved GDT blocks at 294914-295040
 Block bitmap at 295041 (+129), Inode bitmap at 295042 (+130)
 Inode table at 295043-295555 (+131)
 32124 free blocks, 8208 free inodes, 0 directories
 Free blocks: 295556-327679
 Free inodes: 73873-82080
Group 10: (Blocks 327680-360447)
 Block bitmap at 327680 (+0), Inode bitmap at 327681 (+1)
 Inode table at 327682-328194 (+2)
 32253 free blocks, 8208 free inodes, 0 directories
 Free blocks: 328195-360447
 Free inodes: 82081-90288
Group 11: (Blocks 360448-393215)
 Block bitmap at 360448 (+0), Inode bitmap at 360449 (+1)
 Inode table at 360450-360962 (+2)
 32253 free blocks, 8208 free inodes, 0 directories
 Free blocks: 360963-393215
 Free inodes: 90289-98496
Group 12: (Blocks 393216-425983)
 Block bitmap at 393216 (+0), Inode bitmap at 393217 (+1)
 Inode table at 393218-393730 (+2)
 32253 free blocks, 8208 free inodes, 0 directories
 Free blocks: 393731-425983
 Free inodes: 98497-106704
Group 13: (Blocks 425984-458751)
 Block bitmap at 425984 (+0), Inode bitmap at 425985 (+1)
 Inode table at 425986-426498 (+2)
 32253 free blocks, 8208 free inodes, 0 directories
 Free blocks: 426499-458751
 Free inodes: 106705-114912
Group 14: (Blocks 458752-491519)
 Block bitmap at 458752 (+0), Inode bitmap at 458753 (+1)
 Inode table at 458754-459266 (+2)
 32253 free blocks, 8208 free inodes, 0 directories
 Free blocks: 459267-491519
 Free inodes: 114913-123120
Group 15: (Blocks 491520-524287)
 Block bitmap at 491520 (+0), Inode bitmap at 491521 (+1)
 Inode table at 491522-492034 (+2)
 32253 free blocks, 8208 free inodes, 0 directories
 Free blocks: 492035-524287
 Free inodes: 123121-131328
[root@Smoke ~]# dumpe2fs -h /dev/sda5（查看分区sda5设备超级块中信息，-h只显示超级块中的信息）
dumpe2fs 1.41.12 (17-May-2010)
Filesystem volume name:   MYDATA
Last mounted on:          <not available>
Filesystem UUID:          e62edf22-b493-4c86-8b6c-6092c6e26c82
Filesystem magic number:  0xEF53
Filesystem revision #:    1 (dynamic)
Filesystem features:      has_journal ext_attr resize_inode dir_index filetype sparse_super large_file
Filesystem flags:         signed_directory_hash
Default mount options:    (none)
Filesystem state:         clean
Errors behavior:          Continue
Filesystem OS type:       Linux
Inode count:              131328
Block count:              524288
Reserved block count:     26224
Free blocks:              498867
Free inodes:              131317
First block:              0
Block size:               4096
Fragment size:            4096
Reserved GDT blocks:      127
Blocks per group:         32768
Fragments per group:      32768
Inodes per group:         8208
Inode blocks per group:   513
Filesystem created:       Tue Jul 15 23:05:18 2014
Last mount time:          n/a
Last write time:          Tue Jul 15 23:20:25 2014
Mount count:              0
Maximum mount count:      21
Last checked:             Tue Jul 15 23:05:18 2014
Check interval:           15552000 (6 months)
Next check after:         Sun Jan 11 23:05:18 2015
Reserved blocks uid:      0 (user root)
Reserved blocks gid:      0 (group root)
First inode:              11
Inode size:                  256
Required extra isize:     28
Desired extra isize:      28
Journal inode:            8
Default directory hash:   half_md4
Directory Hash Seed:      f5c69b69-55ff-46dd-942f-5882749b50fd
Journal backup:           inode blocks
Journal features:         (none)
Journal size:             64M
Journal length:           16384
Journal sequence:         0x00000001
Journal start:            0
[root@Smoke ~]# df -lh（查看当前系统磁盘分区使用情况，-l或--local仅显示本地端文件系统，-h单位换算）
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda2        20G  5.9G   13G  33% /
tmpfs           495M     0  495M   0% /dev/shm
/dev/sda1       194M   53M  132M  29% /boot
[root@Smoke ~]# dumpe2fs /dev/sda2（查看分区sda2设备文件系统属性信息）
Group 82: (Blocks 2686976-2719743) [ITABLE_ZEROED]
 Checksum 0xc7c6, unused inodes 0
 Block bitmap at 2621442 (+4294901762), Inode bitmap at 2621458 (+4294901778)
 Inode table at 2622492-2623001 (+4294902812)
 1979 free blocks, 4 free inodes, 621 directories
 Free blocks: 2691660-2691711, 2691728-2691810, 2691812-2692165, 2692167-2692260,
 2692262-2692290, 2692292-2692308, 2692310-2692318, 2692320-2692328, 2692330-2692332,
 2692334-2692340, 2692342-2692350, 2692352-2692362, 2692364-2692372, 2692374-2692376,
 2692378-2692385, 2692387-2692395, 2692397-2692401, 2692403-2692412, 2692414-2692435, 
2692437-2692619, 2692621-2692856, 2692859-2693028, 2693031-2693062, 2693064-2693119, 
2709504-2709912, 2709916-2710015, 2710064-2710079, 2710238-2710271（出现磁盘碎片，离散的磁盘块，需要磁盘整理）
[root@Smoke ~]# e2fsck /dev/sda5（修复分区sda5设备，专用于修复ext2/ext3文件系统）
e2fsck 1.41.12 (17-May-2010)
MYDATA: clean(干净), 11/131328 files, 25421/524288 blocks
[root@Smoke ~]# e2fsck -f /dev/sda5(修复分区sda5设备，专用于修复ext2/ext3文件系统，-f强制修复）
e2fsck 1.41.12 (17-May-2010)
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
MYDATA: 11/131328 files (0.0% non-contiguous), 25421/524288 blocks
[root@Smoke ~]# e2fsck -f -p /dev/sda5(修复分区sda5设备，专用于修复ext2/ext3文件系统，-f强制修复，-p自动修复）
MYDATA: 11/131328 files (0.0% non-contiguous), 25421/524288 blocks
[root@Smoke ~]# blkid /dev/sda5（查看分区sda5设备相关属性）
/dev/sda5: LABEL="MYDATA" UUID="e62edf22-b493-4c86-8b6c-6092c6e26c82" SEC_TYPE="ext2" TYPE="ext3"
[root@Smoke ~]# mkdir /mnt/test（创建目录test)
[root@Smoke ~]# mount /dev/sda5 /mnt/test/（将分区sda5设备挂载到/mnt/test目录）
[root@Smoke ~]# cd /mnt/test/（切换到/mnt/test目录）
[root@Smoke test]# ls（查看当前目录文件及子目录，任何一个新建的文件系统，刚格式化完的里面有lost+found目录）
lost+found
[root@Smoke mnt]# umount /dev/sda5（卸载分区sda5的挂载）
[root@Smoke mnt]# umount /mnt/test/（卸载挂载点/mnt/test目录所挂载的设备）
[root@Smoke mnt]# mount(显示当前系统已经挂载的设备及挂载点)
/dev/sda2 on / type ext4 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
tmpfs on /dev/shm type tmpfs (rw)
/dev/sda1 on /boot type ext4 (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
vmware-vmblock on /var/run/vmblock-fuse type fuse.vmware-vmblock (rw,nosuid,nodev,default_permissions,allow_other)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
nfsd on /proc/fs/nfsd type nfsd (rw)
[root@Smoke mnt]# mount(显示当前系统已经挂载的设备及挂载点)
/dev/sda2 on / type ext4 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
tmpfs on /dev/shm type tmpfs (rw)
/dev/sda1 on /boot type ext4 (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
vmware-vmblock on /var/run/vmblock-fuse type fuse.vmware-vmblock (rw,nosuid,nodev,default_permissions,allow_other)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
nfsd on /proc/fs/nfsd type nfsd (rw)
[root@Smoke mnt]# mount /dev/sda5 /mnt/test/(将分区sda5设备挂载到/mnt/test目录）
[root@Smoke mnt]# cat /etc/mtab（查看mtab文件的内容）
/dev/sda2 / ext4 rw 0 0
proc /proc proc rw 0 0
sysfs /sys sysfs rw 0 0
devpts /dev/pts devpts rw,gid=5,mode=620 0 0
tmpfs /dev/shm tmpfs rw 0 0
/dev/sda1 /boot ext4 rw 0 0
none /proc/sys/fs/binfmt_misc binfmt_misc rw 0 0
vmware-vmblock /var/run/vmblock-fuse fuse.vmware-vmblock rw,nosuid,nodev,default_permissions,allow_other 0 0
sunrpc /var/lib/nfs/rpc_pipefs rpc_pipefs rw 0 0
nfsd /proc/fs/nfsd nfsd rw 0 0
/dev/sda5 /mnt/test ext3 rw 0 0
[root@Smoke mnt]# umount /dev/sda5（卸载分区sda5设备的挂载）
[root@Smoke mnt]# cat /etc/mtab（查看/etc/mtab文件内容）
/dev/sda2 / ext4 rw 0 0
proc /proc proc rw 0 0
sysfs /sys sysfs rw 0 0
devpts /dev/pts devpts rw,gid=5,mode=620 0 0
tmpfs /dev/shm tmpfs rw 0 0
/dev/sda1 /boot ext4 rw 0 0
none /proc/sys/fs/binfmt_misc binfmt_misc rw 0 0
vmware-vmblock /var/run/vmblock-fuse fuse.vmware-vmblock rw,nosuid,nodev,default_permissions,allow_other 0 0
sunrpc /var/lib/nfs/rpc_pipefs rpc_pipefs rw 0 0
nfsd /proc/fs/nfsd nfsd rw 0 0
[root@Smoke mnt]# mount -n /dev/sda5 /mnt/test/（挂载分区sda5设备到/mnt/test挂载点，-n不把信息写入/etc/mtab文件）
[root@Smoke mnt]# cat /etc/mtab（显示/etc/mtab文件内容）
/dev/sda2 / ext4 rw 0 0
proc /proc proc rw 0 0
sysfs /sys sysfs rw 0 0
devpts /dev/pts devpts rw,gid=5,mode=620 0 0
tmpfs /dev/shm tmpfs rw 0 0
/dev/sda1 /boot ext4 rw 0 0
none /proc/sys/fs/binfmt_misc binfmt_misc rw 0 0
vmware-vmblock /var/run/vmblock-fuse fuse.vmware-vmblock rw,nosuid,nodev,default_permissions,allow_other 0 0
sunrpc /var/lib/nfs/rpc_pipefs rpc_pipefs rw 0 0
nfsd /proc/fs/nfsd nfsd rw 0 0
[root@Smoke mnt]# mount /dev/cdrom /media/（挂载cdrom设备到/media目录下）
mount: block device /dev/sr0 is write-protected(写保护), mounting read-only（只读）
[root@Smoke mnt]# umount /media/(卸载/media挂载点的设备）
[root@Smoke mnt]# mount -r /dev/cdrom /media/（挂载cdrom设备到/media目录，-r只读方式挂载，不会显示警告信息）
[root@Smoke mnt]# umount /media/(卸载/media挂载点的设备）
[root@Smoke mnt]# mount -o ro /dev/cdrom /media/（挂载cdrom设备到/media目录下，-o指定挂载文件系统功能，ro只读，不会弹出警告信息）
[root@Smoke mnt]# mount -o remount /dev/cdrom /media/(重新挂载cdrom到/media目录，-o指定挂载文件系统功能，remount重新挂载，先卸载再挂载）
[root@Smoke mnt]# mount /dev/sda5 /mnt/test/
[root@Smoke mnt]# mount
/dev/sda2 on / type ext4 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
tmpfs on /dev/shm type tmpfs (rw)
/dev/sda1 on /boot type ext4 (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
vmware-vmblock on /var/run/vmblock-fuse type fuse.vmware-vmblock (rw,nosuid,nodev,default_permissions,allow_other)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
nfsd on /proc/fs/nfsd type nfsd (rw)
/dev/sr0 on /media type iso9660 (rw)
/dev/sda5 on /mnt/test type ext3 (rw)
[root@Smoke mnt]# mount -o remount,ro /dev/sda5（重新挂载sda5设备，重新挂载不用指定挂载点也可以，-o指定挂载文件系统功能，remount重新挂载，先卸载再挂载，ro只读方式挂载，
多个选项逗号隔开）
[root@Smoke mnt]# mount
/dev/sda2 on / type ext4 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
tmpfs on /dev/shm type tmpfs (rw)
/dev/sda1 on /boot type ext4 (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
vmware-vmblock on /var/run/vmblock-fuse type fuse.vmware-vmblock (rw,nosuid,nodev,default_permissions,allow_other)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
nfsd on /proc/fs/nfsd type nfsd (rw)
/dev/sr0 on /media type iso9660 (rw)
/dev/sda5 on /mnt/test type ext3 (ro)

练习：

1、创建一个2G的分区，文件系统为ext2，卷标为DATA，块大小为1024，预留管理空间为磁盘分区的8%；挂载至/backup目录，要求使用卷标进行挂载，且在挂载时启动此文件系统上的acl功能；

# mke2fs -L DATA -b 1024 -m 8  /dev/sda7
# mount -o acl LABEL=DATA /backup
# tune2fs -o acl /dev/sda7
# mount LABEL=DATA /backup

[root@Smoke ~]# mke2fs -L DATA -b 1024 -m 8 /dev/sda5
[root@Smoke ~]# tune2fs -o acl /dev/sda5
[root@Smoke ~]# mount -t ext2 LABEL=DATA /backup/

2、将此文件系统的超级块中的信息中包含了block和inode的行保存至/tmp/partition.txt中；

# tune2fs -l | egrep -i "block|inode" >> /tmp/partition.txt 
# dumpe2fs -h |

[root@Smoke ~]# dumpe2fs -h /dev/sda5 | egrep -i "block|inode" >> /tmp/partition.txt
[root@Smoke ~]# tune2fs -l /dev/sda5 | egrep -i "block|inode" >> /tmp/partition.txt

3、复制/etc目录中的所有文件至此文件系统；而后调整此文件系统类型为ext3，要求不能损坏已经复制而来的文件；

# cp -r /etc/*  /backup
# tune2        -j /dev/sda7

[root@Smoke /]# \cp -r /etc/* /backup/
[root@Smoke /]# tune2fs -j LABEL=DATA

4、调整其预留百分比为3%；

# tune2fs -m 3 -L DATA /dev/sda7

[root@Smoke /]# tune2fs -m 3 LABEL=DATA

5、以重新挂载的方式挂载此文件系统为不更新访问时间戳，并验正其效果；

# stat /backup/inittab
# cat /backup/inittab
# stat
# mount -o remount,noatime /backup
# cat
# stat

[root@Smoke /]# mount -o remount,noatime LABEL=DATA
[root@Smoke /]# stat /backup/inittab
[root@Smoke /]# cat /backup/inittab

6、对此文件系统强行做一次检测；

e2fsck -f /dev/sda7

[root@Smoke /]# e2fsck -f LABEL=DATA

7、删除复制而来的所有文件，并将此文件系统重新挂载为同步(sync)；而后再次复制/etc目录中的所有文件至此挂载点，体验其性能变化；

# rm -rf /backup/*
# mount -o remount,sync /backup
# cp -r /etc/* /backup

[root@Smoke /]# rm -rf /backup/*
[root@Smoke /]# mount -o remount,sync LABEL=DATA
[root@Smoke /]# \cp -r /etc/* /backup/

swap分区：
虚拟内存：
操作系统是一个虚拟机，将底层硬件所提供的计算能力虚拟出来，虚拟成一个接口，能够让多个进程并行运行，操作系统内核就是一个虚拟机，把我们底层的硬件资源通过timesharing(时间共享)或通过multiplex(多路复用)等各种机制，将一个资源给它平均分成N份，每一个进程都可以使用一份，在这其中，对于计算机而言非它的组件也只有CPU、内存、I/O设备；CPU虚拟可以将划分成一个一个time slice(时间片)，CPU的计算是通过时间的流逝来完成的，根据时间来完成的，因此只需要把CPU时间，例如以5毫秒为一个计算片段划分出来，给它平均分配到多个进程上去，而I/O设备它通常使用多路复用来完成的，内存叫可编址的存储单元，所以进程在访问内存设备的时候，我们内存每一个存储空间，每一个字节8位，称为一个存储单元/存储格，每一个存储格都是有地址的，所以CPU访问内存中的数据的时候，就是根据地址来查找的，地址总线就是用来负责寻址的，告诉你在某个地址上，CPU通过地址总线能够找到对应地址存储单元，而后通过数据总线把这个数据给它读取出来，但是在控制指令的控制下，从数据总线完成数据读取，这些称为编址的存储单元，当我们在一个内存运行多个进程的时候，每一个进程都要自我去管理其内存空间的话，如果其中一个进程出现了BUG把其他进程的数据给覆盖掉了怎么办，一个进程出现BUG它访问了本来不属于它的空间，所有在这种场景下如何去避免进程彼此之间互相覆盖的现象发生，在X86(32bit)以后引入了虚拟地址或线性地址的概念，就意味着每一个进程运行的时候，它不管你的物理内存是多少，它就假设自己是直接运行在4G可用空间上，假设自己一共有4G存储空间可用，事实上当我们的操作系统启动起来以后载我们的主机上进程是运行在内核之上的，所以我们的内存空间里面虽然是4G，但进程并不意味着自己可以直接使用这4G，而是把这4G划分为两段，最低端的1G是内核用的，上面3G是我们进程使用的，但是这个地址空间是虚拟出来的，是假的，它并不存在，真正用户所访问的时候，真正的数据还应该放在物理内存当中，但是有些进程启动起来以后它所需要的内存空间很小，虽然是假设自己有3G可用，但是它仅仅使用到其中的很小一部分，而在这一部分当中里面大多数的进程空间是page frame(分页)的，在物理空间当中它把自己存储空间分为一个一个页框，每4K一个页框，可以放一个页面数据，就是每4K作为一个存储空间，可以存储4K的数据，而后每一个进程在运行的时候它真正使用的数据会被转换映射到这个空间里面来，它们是交替存储的，在物理上可能是不连续的，所以我们的物理内存就是通过这种方式将其中的存储空间给它分配给了不同的进程，但是每一个进程假设自己就有4G空间的3G可用，它看上去自己一共有4G可用，而且这4G空间放的好好的，没有任何人用，但是背后偷偷的由操作系统将它转换成物理内存了，这个空间空间叫做虚拟地址，而物理内存所提供的地址空间称为物理地址，所以虚拟地址是假的，每个进程都认为自己是4G的，所以它是看不到其他进程存在的，因为它一共就知道这个设备一共就有4G物理内存，而自己全部占据了，所以它是意识不到其他进程存在，每个进程都假设自己有4G空间可用，或者有3G可用，事实上物理内存很可能一共只有2G，所以每个进程都假设自己有那么大空间可用，一会运行了100个进程，就算每隔进程用了20M，需要占据2G空间，更何况内核还需要占据一部分空间，这时候万一物理内存里面没有页框了，但是这个进程说还需要存一个新的数据过来，还要再生成一个新的页面，这个数据页面放那里，物理内存几乎快被占满了，没有多余的可用，这里我又需要一个新数据，进程它不知道，它只知道自己空间还多着呢，它并不知道物理内存事实上已经满了，它自己才占了20M，还以为自己还多着呢，还有2个多G，于是不停去申请新的空间来装数据，但是物理资源已经有限，已经接近于上限了，这时候怎么办，可以在硬盘上找一个分区，或者找一段存储空间，把这段存储空间也划分成一个一个页框，模拟成内存，它里面也有很多的页框，可以存储页面数据的存储格子，可以在物理内存当中把那些最近最少使用的页面给它挪进来，这样就腾出来空间，腾出来空间给你建立上关系，第一个进程不是要申请空间，让它使用这段空间，过一会很少使用的页面的进程又醒来了，它又开始找它这段数据，找出来的不是正确的，一旦发生这种情况，当某一个进程中的某一个页框数据被放到硬盘上去以后，内核会偷偷的把这里面的映射表指向关系给它消除，但是自己在内部维护有一张表，它知道消除以后给它挪到那去了，所以当这个家伙醒过来又找它数据的时候，我们内核马上会醒过来，让等一会，内核把它的申请截下来，把其他进程的页框再挪到硬盘，再把它的数据再放到内存中来，放到内存以后可能已经是别的地址了，这时内核再告诉你，更换了地址空间，于是它就使用新的位置中的数据了，而这个过程就被称为叫唤进唤出的过程，把一个页面数据给它交换出去，再给它交换回来，磁盘这段空间称为交换空间，交换空间存储允许了内存过载的使用，如果没有交换空间，要超过使用是不可能的，正式交换空间存储，使得我们允许内存overcommit(过载)使用，过载使用这种方式固然可让系统运行所有进程所需要的内存超出物理内存空间，但是只要把这个页面换进来换出去，换出去换进来必然会影响系统性能，所以不到万不得以的时候，不建议使用交换空间，但是交换空间可以作为应急使用，一旦物理内存耗尽了，可以临时拿交换空间来应急，没有交换空间的话，一旦内存满了，这时候操作系统自身都转不动声了，整个系统就被挤爆了，接下来就可能宕机了，这是非常危险的，对服务器来讲，因此有了过载空间，我们可以将最近很少使用的数据给它先挪出去，让操作系统自身能转出身，然后能做一些清理操作，比如将那些最近很少运行的进程，那些可能出现了BUG吞噬的进程统统给它杀死，要么清出去，腾出来更多的内存空间等等；

X86:

虚拟地址，线性地址

在Linux上交换机分区必须是单独的分区，这个分区叫做swap分区；

把内存中的数据放到磁盘上的过程叫做page out,当把数据从硬盘上取回进内存中叫page in,站在swap角度叫做swap out或者swap in,它们俩是对立的，如果操作系统频繁的有页面数据换出换进，换进换出，这就是物理内存太小了；

查看当前系统的物理内存和交换空间使用情况：

free：

-m：默认单位是bytes,以M为单位显示空间大小

fdisk命令中，调整分区类型为82；

创建交换分区：

mkswap /dev/sda8

　　-L LABEL：使用卷标创建交换分区

swapon /dev/sda8：启用设备上的交换空间

　　-a:启用所有的定义在/etc/fstab文件中的交换设备

swapoff /dev/sda8：

问题环境：磁盘上已经没有新的空间可以创建分区了，但是在某个分区里面已经挂载的位置还有很多空闲空间可以使用，但是就是没有空间空间可以创建新的分区，交换分区必须是一个独立的分区，这时主机上的交换分区已经不够用了，如何应急；

回环设备

loopback, 使用软件来模拟实现硬件

可以在本地文件系统上创建一个镜像文件，让这个文件具有1G空间大小，把这1G空间直接当成一个设备来使用也是可以的，这个1G空间还可以模拟成120G空间，模拟出来还可以当硬盘来使用，还可以挂载、分区、格式化；但这个文件可能1M都不到，但是fdisk命令看起来是120G的，这完全可以实现，所以把这种设备叫做本地回环设备，实在没有空间可用，又急着创建交换分区，怎么办，就创建一个本地回环设备，然后再把它格式化成swap分区，然后在启动起来就可以了；

dd if=/dev/sda of=/mnt/usb/mbr.backup bs=512 count=1：备份MBR，没有指文件，指sda硬盘，就从sda硬盘最开头复制，硬盘最开头就是MBR，bs复制512bytes，count复制1个这样单位，就是硬盘最开始处的512字节，就是MBR数据

dd if=/mnt/usb/mbr.backup of=/dev/sda bs=512 count=1：回复MBR，从某个设备备份的mbr.backup文件复制到sda硬盘设备，bs复制512bytes，count复制1个这样单位，复制到硬盘sda前512bytes上；

dd if=/dev/zero of=/var/swapfile bs=1M count=1024：从/dev/zero最开始处读数据，bs以1M为单位，count读1024个bs，保存到/var/swapfile，创建大小为1024M的虚拟镜像文件，而这个镜像文件可以mkswap，并且把它启动起来；

/dev/zero：泡泡机，能够向外吐0，要多少有多少

/dev/null：数据黑洞，给它多少吞多少数据

dd还可以做光盘镜像：

dd if=/dev/cdrom of=/root/rhel5.iso

使用cat做磁盘镜像:

cat /dev/cdrom > /root/rhel5.iso

dd和cp复制文件不同：

cp复制文件是按照以文件为单位复制，而dd复制文件它不是以文件为单位复制，但是dd直接复制的是底层的数据流；在磁盘上的文件最终是要被文件系统组织成以文件为单位来进行管理的，所以cp复制的时候，是把原文件通过文件系统读取出来，读到内存里面来，再给它粘贴到指定的另外一个位置，这样就完成复制了，所以在我们cp命令看来这个数据要先通过VFS这种接口以文件为单位读取到内存里面来，再重新保存至另外一个文件所对应的位置去，而对于dd命令来讲，它不通过VFS，而直接把这个文件对应的01代码复制到另一个位置，它是直接复制这种01这种代码，而不是文件对应那个文件视角的数据，对cp看来文件就是文件，不是01代码，由文件系统输出的文件系统数据，dd好处可以只复制文件的一部分；

mount命令，可以挂载iso镜像；

mount DEVICE MOUNT_POINT

　　-o loop: 挂载本地回环设备，可以用作挂载iso文件；

wget ftp://172.16.0.1/pub/isos/rhci-5.8-1.iso ：通过网络下载文件

mount /dev/sda5 /mnt/test

文件系统的配置文件/etc/fstab

　　OS在初始时，会自动挂载此文件中定义的每个文件系统

要挂载的设备　　　　挂载点　　　　文件系统类型　　　　挂载选项　　　　转储频率(每多少天做一次完全备份)　　　　文件系统检测次序(只有根可以为1)
/dev/sda5　　　　　  /mnt/test　　　 ext3 　　　　　　　   defaults 　　　　 0 　　　　　　　　　　　　　　　　　　   0

要挂在的设备：可以使用设备文件、UUID、LABEL，跟使用mount命令是一样的；

挂载点：打算把设备挂载到什么位置；

文件系统类型：ext2、ext3、ext4...

挂载选项：类似与mount -o [option]指定额外的挂载选项，也即指定文件系统启用的属性；defaults：如果没指挂载选项，就使用默认选项：rw,suid,dev,exec,nouser,async选项

转储频率：每多少天做一次完全备份，0表示不备份，1表示每天都做完全备份，2表示每2天一次等等；

文件系统检测次序：每一次开机的时候，检测文件系统，先检测那一个，后检测那一个，一般只有根可以为1，因为只有根需要先检测，2表示根检测完以后检测，依次类推等等，但是其他文件系统都可以为2，在根检测完以后同时检查，0表示不检测；

mount -a：挂载/etc/fstab文件中定义的所有文件系统

问题环境：你挂载一个设备，刚挂上去其他人发现了，它登录进去开始访问，挂了为了测试，挂了怎么卸载就卸载不掉；告诉你busy(设备忙碌)；

fuser: 验正进程正在使用的文件或套接字文件

　　-v: 查看某文件上正在运行的进程

　　-k: 把正在访问文件的进程杀死

　　-m：指定一个被加载的文件系统或一个被加载的块设备

　　fuser -km MOUNT_POINT：终止正在访问此挂载点的所有进程，会连访问用户的bash都踢出；

swap分区挂载方式：

UUID=fb6d8ea4-ed81-4024-bcbc-7bc44f431282　　　　swap　　　　swap　　　　defaults　　　　0　　　　0

[root@Smoke ~]# free（查看当前系统的物理内存和交换空间使用情况）
            total       used       free     shared    buffers     cached
Mem:       1012348     226232     786116          0      30496      81096
-/+ buffers/cache:     114640     897708
Swap:      1048568          0    1048568
[root@Smoke ~]# free -m（查看当前系统的物理内存和交换空间使用情况，-m以M为单位显示空间大小）
            total(总大小)       used(已使用空间)       free(空闲空间)     shared    buffers(缓冲)     cached(缓存)
Mem(物理内存):           988        221        767          0         29         79
-/+ buffers/cache:        112        876
Swap(交换内存):         1023          0       1023
创建交换分区：
[root@Smoke ~]# fdisk /dev/sda（管理磁盘分区，进入交互式）
WARNING: DOS-compatible mode is deprecated. It's strongly recommended to
        switch off the mode (command 'c') and change display units to
        sectors (command 'u').
Command (m for help): p（显示当前磁盘的分区）
Disk /dev/sda: 42.9 GB, 42949672960 bytes
255 heads, 63 sectors/track, 5221 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00031216
  Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1          26      204800   83  Linux
Partition 1 does not end on cylinder boundary.
/dev/sda2              26        2576    20480000   83  Linux
/dev/sda3            2576        2706     1048576   82  Linux swap / Solaris
/dev/sda4            2706        5221    20203282+   5  Extended
/dev/sda5            2706        2967     2097996   83  Linux
/dev/sda6            2968        3621     5253223+  83  Linux
/dev/sda7            3622        3753     1060258+  83  Linux
Command (m for help): n（新建分区）
First cylinder (3754-5221, default 3754):
Using default value 3754
Last cylinder, +cylinders or +size{K,M,G} (3754-5221, default 5221): +1G
Command (m for help): L（显示支持的文件系统类型）
0  Empty           24  NEC DOS         81  Minix / old Lin bf  Solaris        
1  FAT12           39  Plan 9          82  Linux swap / So c1  DRDOS/sec (FAT-
2  XENIX root      3c  PartitionMagic  83  Linux           c4  DRDOS/sec (FAT-
3  XENIX usr       40  Venix 80286     84  OS/2 hidden C:  c6  DRDOS/sec (FAT-
4  FAT16 <32M      41  PPC PReP Boot   85  Linux extended  c7  Syrinx        
5  Extended        42  SFS             86  NTFS volume set da  Non-FS data    
6  FAT16           4d  QNX4.x          87  NTFS volume set db  CP/M / CTOS / .
7  HPFS/NTFS       4e  QNX4.x 2nd part 88  Linux plaintext de  Dell Utility  
8  AIX             4f  QNX4.x 3rd part 8e  Linux LVM       df  BootIt        
9  AIX bootable    50  OnTrack DM      93  Amoeba          e1  DOS access    
a  OS/2 Boot Manag 51  OnTrack DM6 Aux 94  Amoeba BBT      e3  DOS R/O        
b  W95 FAT32       52  CP/M            9f  BSD/OS          e4  SpeedStor      
c  W95 FAT32 (LBA) 53  OnTrack DM6 Aux a0  IBM Thinkpad hi eb  BeOS fs        
e  W95 FAT16 (LBA) 54  OnTrackDM6      a5  FreeBSD         ee  GPT            
f  W95 Ext'd (LBA) 55  EZ-Drive        a6  OpenBSD         ef  EFI (FAT-12/16/
10  OPUS            56  Golden Bow      a7  NeXTSTEP        f0  Linux/PA-RISC b
11  Hidden FAT12    5c  Priam Edisk     a8  Darwin UFS      f1  SpeedStor      
12  Compaq diagnost 61  SpeedStor       a9  NetBSD          f4  SpeedStor      
14  Hidden FAT16 <3 63  GNU HURD or Sys ab  Darwin boot     f2  DOS secondary  
16  Hidden FAT16    64  Novell Netware  af  HFS / HFS+      fb  VMware VMFS    
17  Hidden HPFS/NTF 65  Novell Netware  b7  BSDI fs         fc  VMware VMKCORE
18  AST SmartSleep  70  DiskSecure Mult b8  BSDI swap       fd  Linux raid auto
1b  Hidden W95 FAT3 75  PC/IX           bb  Boot Wizard hid fe  LANstep        
1c  Hidden W95 FAT3 80  Old Minix       be  Solaris boot    ff  BBT            
1e  Hidden W95 FAT1
Command (m for help): t（更改分区类型）
Partition number (1-8): 8（选择第8个分区）
Hex code (type L to list codes): 82（更改为linux swap类型分区）
Changed system type of partition 8 to 82 (Linux swap / Solaris)
Command (m for help): p（显示磁盘分区情况）
Disk /dev/sda: 42.9 GB, 42949672960 bytes
255 heads, 63 sectors/track, 5221 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x00031216
  Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1          26      204800   83  Linux
Partition 1 does not end on cylinder boundary.
/dev/sda2              26        2576    20480000   83  Linux
/dev/sda3            2576        2706     1048576   82  Linux swap / Solaris
/dev/sda4            2706        5221    20203282+   5  Extended
/dev/sda5            2706        2967     2097996   83  Linux
/dev/sda6            2968        3621     5253223+  83  Linux
/dev/sda7            3622        3753     1060258+  83  Linux
/dev/sda8            3754        3885     1060258+  82  Linux swap / Solaris
Command (m for help): w（保存退出）
The partition table has been altered!
Calling ioctl() to re-read partition table.
WARNING: Re-reading the partition table failed with error 16: Device or resource busy.
The kernel still uses the old table. The new table will be used at
the next reboot or after you run partprobe(8) or kpartx(8)
Syncing disks.
[root@Smoke ~]# partprobe /dev/sda（让内核重新读取分区表）
[root@Smoke ~]# partx -a /dev/sda（centos 6.x重读分区表命令，-a添加指定分区或磁盘读取并添加所有分区）
[root@Smoke ~]# blkid /dev/sda8（创建分区sda8设备为swap类型文件系统）
/dev/sda8: UUID="bcbcce69-2936-4aee-b352-e5f7c25a21b3" TYPE="swap"
[root@Smoke ~]# free -m（查看系统上内存和交换空间使用情况，交换空间只有1G）
            total       used       free     shared    buffers     cached
Mem:           988        353        634          0         41        184
-/+ buffers/cache:        127        861
Swap:         1023          0       1023
[root@Smoke ~]# swapon /dev/sda8（启用文件系统sda8设备上的交换空间）
[root@Smoke ~]# free -m（查看系统上内存和交换空间使用情况，交换空间增加到2G)
            total       used       free     shared    buffers     cached
Mem:           988        354        634          0         41        184
-/+ buffers/cache:        128        860
Swap:         2059          0       2059
[root@Smoke ~]# swapoff /dev/sda8（关闭文件系统sda8设备的交换空间）
[root@Smoke ~]# free -m（查看系统上内存和交换空间使用情况，交换空间变为1G)
            total       used       free     shared    buffers     cached
Mem:           988        353        634          0         41        184
-/+ buffers/cache:        127        861
Swap:         1023          0       1023
[root@Smoke ~]# dd if=/etc/inittab of=/root/inittab（使用dd命令复制/etc/inittab文件到/root/inittab）
1+1 records in
1+1 records out
884 bytes (884 B) copied, 0.000341557 s, 2.6 MB/s
[root@Smoke ~]# cat /root/inittab（查看inittab文件内容）
# inittab is only used by upstart for the default runlevel.
#
# ADDING OTHER CONFIGURATION HERE WILL HAVE NO EFFECT ON YOUR SYSTEM.
#
# System initialization is started by /etc/init/rcS.conf
#
# Individual runlevels are started by /etc/init/rc.conf
#
# Ctrl-Alt-Delete is handled by /etc/init/control-alt-delete.conf
#
# Terminal gettys are handled by /etc/init/tty.conf and /etc/init/serial.conf,
# with configuration in /etc/sysconfig/init.
#
# For information on how to write upstart event handlers, or how
# upstart works, see init(5), init(8), and initctl(8).
#
# Default runlevel. The runlevels used are:
#   0 - halt (Do NOT set initdefault to this)
#   1 - Single user mode
#   2 - Multiuser, without NFS (The same as 3, if you do not have networking)
#   3 - Full multiuser mode
#   4 - unused
#   5 - X11
#   6 - reboot (Do NOT set initdefault to this)
#
id:3:initdefault:
使用本地回环文件模拟交换分区：
[root@Smoke ~]# dd if=/dev/zero of=/var/swapfile bs=1M count=1024（创建1G镜像文件）
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB) copied, 28.621 s, 37.5 MB/s
[root@Smoke ~]# ls -lh /var/swapfile（查看/var/swapfile文件详细信息）
-rw-r--r-- 1 root root 1.0G Jul 18 23:36 /var/swapfile
[root@Smoke ~]# mkswap /var/swapfile（创建swapfile文件为swap分区）
mkswap: /var/swapfile: warning: don't erase bootbits sectors
       on whole disk. Use -f to force.
Setting up swapspace version 1, size = 1048572 KiB
no label, UUID=169ac050-e29b-4502-a1b1-3e97dc1394d7
[root@Smoke ~]# free -m(查看内存和交换空间使用情况，-m以M为单位显示，swap只有1023）
            total       used       free     shared    buffers     cached
Mem:           988        917         70          0          7        784
-/+ buffers/cache:        125        862
Swap:         1023          0       1023
[root@Smoke ~]# swapon /var/swapfile（启用文件模拟的交换空间）
[root@Smoke ~]# free -m（查看内存和交换空间使用情况，-m以M为单位显示，swap变为2047）
            total       used       free     shared    buffers     cached
Mem:           988        920         67          0          7        785
-/+ buffers/cache:        127        861
Swap:         2047          0       2047
[root@Smoke ~]# dd if=/dev/zero of=/var/swapfile2 seek=1023 bs=1M count=1024（从/dev/zero设备最开头跳过1023M，再复制1024M，seek虚拟出来1G，
count复制1G，总共2G)
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB) copied, 2.89187 s, 371 MB/s
[root@Smoke ~]# ls -lh /var/swapfile2(查看wapfile2详细信息，-h单位换算）
-rw-r--r-- 1 root root 2.0G Jul 18 23:58 /var/swapfile2
[root@Smoke ~]# dd if=/dev/zero of=/var/swapfile2 seek=1023 bs=1M count=1（创建1024M文件，前面1023M跳过去，是假的）
1+0 records in
1+0 records out
1048576 bytes (1.0 MB) copied, 0.00353432 s, 297 MB/s
[root@Smoke ~]# ls -lh /var/swapfile2(查看wapfile2详细信息，-h单位换算）
-rw-r--r-- 1 root root 1.0G Jul 19 00:02 /var/swapfile2
[root@Smoke ~]# du -sh /var/swapfile2(显示swapfile2文件系统或者目录它所占据整体空间大小，-s所有文件，-h单位换算，swapfile2真实大小只有1M）
1.0M        /var/swapfile2
[root@Smoke ~]# wget http://mirrors.163.com/centos/6.5/isos/x86_64/CentOS-6.5-x86_64-netinstall.iso （通过网络下载iso文件）
--2014-07-19 23:14:46--   http://mirrors.163.com/centos/6.5/isos/x86_64/CentOS-6.5-x86_64-netinstall.iso
Resolving mirrors.163.com... 123.58.173.106
Connecting to mirrors.163.com|123.58.173.106|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 254803968 (243M) [application/octet-stream]
Saving to: "CentOS-6.5-x86_64-netinstall.iso"
[root@Smoke ~]# mount -o loop /root/CentOS-6.5-x86_64-netinstall.iso /media/（挂载镜像文件到/media目录，-o指定额外的挂载选项，
也即指定文件系统启用的属性，loop挂载本地回环设备）
[root@Smoke ~]# ls /media/（查看/media目录下文件及子目录）
images  isolinux
[root@Smoke ~]# swapoff /var/swapfile（关闭文件swapfile虚拟的交换空间）
[root@Smoke ~]# swapon -a（启动所有定义在/etc/fstab文件中的交换设备）
[root@Smoke ~]# free -m（查看内存和交换空间使用情况，swap大小为1023没有改变，因为/etc/fstab中没有定义交换空间设备）
            total       used       free     shared    buffers     cached
Mem:           988        921         67          0         11        785
-/+ buffers/cache:        123        864
Swap:         1023          0       1023
[root@Smoke ~]# cat /etc/fstab（查看/etc/fstab文件，文件系统挂载配置文件）
UUID=9f66aadb-2e9a-49d5-9748-ceceea2d41f0(要挂载的设备) /(挂载点)                       ext4(文件系统类型）    defaults(挂载选项)        
1(转储频率(每多少天做一次完全备份)) 1(文件系统检测次序(只有根可以为1))
UUID=67344573-c4c0-4b5f-beae-e6837a9712f7 /boot                   ext4    defaults        1 2
UUID=fb6d8ea4-ed81-4024-bcbc-7bc44f431282 swap                    swap    defaults        0 0
tmpfs                   /dev/shm                tmpfs   defaults        0 0
devpts                  /dev/pts                devpts  gid=5,mode=620  0 0
sysfs                   /sys                    sysfs   defaults        0 0
proc                    /proc                   proc    defaults        0 0
[root@Smoke ~]# umount /dev/sda5（卸载文件系统sda5设备)
[root@Smoke ~]# mount(查看当前系统上所有挂载的设备）
/dev/sda2 on / type ext4 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
tmpfs on /dev/shm type tmpfs (rw)
/dev/sda1 on /boot type ext4 (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
vmware-vmblock on /var/run/vmblock-fuse type fuse.vmware-vmblock (rw,nosuid,nodev,default_permissions,allow_other)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
nfsd on /proc/fs/nfsd type nfsd (rw)
/dev/sr0 on /media type iso9660 (rw)
/root/CentOS-6.5-x86_64-netinstall.iso on /media type iso9660 (rw,loop=/dev/loop0)
[root@Smoke ~]# vim /etc/fstab(编辑/etc/fstab文件）
/dev/sda5               /mnt/test               ext3    defaults        0 0
[root@Smoke ~]# mount -a（挂载/etc/fstab文件中所有设备）[root@Smoke ~]# mount（查看系统上所有文件系统设备）
/dev/sda2 on / type ext4 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
tmpfs on /dev/shm type tmpfs (rw)
/dev/sda1 on /boot type ext4 (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
vmware-vmblock on /var/run/vmblock-fuse type fuse.vmware-vmblock (rw,nosuid,nodev,default_permissions,allow_other)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
nfsd on /proc/fs/nfsd type nfsd (rw)
/dev/sr0 on /media type iso9660 (rw)
/root/CentOS-6.5-x86_64-netinstall.iso on /media type iso9660 (rw,loop=/dev/loop0)
/dev/sda5 on /mnt/test type ext3 (rw)
[root@Smoke ~]# cd /mnt/test/（切换到/mnt/test目录)
[root@Smoke test]#
[root@Smoke ~]# umount /dev/sda5(无法卸载文件系统）
umount: /mnt/test: device is busy.
       (In some cases useful info about processes that use
        the device is found by lsof(8) or fuser(1))
[root@Smoke ~]# fuser -v /mnt/test/（验证进程正则使用的文件或套接字文件；-v: 查看某文件上正在运行的进程）
                    USER        PID ACCESS COMMAND
/mnt/test/:          root       7559 ..c.. bash
[root@Smoke ~]# fuser -km /mnt/test/(把/mnt/test挂载点上正在访问的进程统统杀死，会连用户的bash都踢出去）
/mnt/test/:           7559c
[root@Smoke ~]# umount /mnt/test/（卸载/mnt/test挂载点上的设备）

练习：

1、创建一个5G的分区，文件系统为ext3，卷标为MYDATA，块大小为1024，预留管理空间为磁盘分区的3%，要求开机后可以自动挂载至/data目录，并且自动挂载的设备要使用卷标进行引用；

[root@Smoke ~]# mke2fs -j  -L MYDATA -b 1024 -m 3 /dev/sda5
[root@Smoke ~]# vim /etc/fstab
LABEL=MYDATA            /data                   ext3    defaults        0 0

2、创建一个本地回环文件/var/swaptemp/swapfile来用于swap，要求大小为512MB，卷标为SWAP-FILE，且开机自动启用此交换设备；

# mkdir /var/swaptemp
# dd if=/dev/zero of=/var/swaptemp/swapfile bs=1M count=512
# mkswap LABLE=SWAP-FILE /var/swaptemp/swapfile
/etc/fstab
/var/swaptemp/swapfile          swap                swap                defaults                0 0

[root@Smoke ~]# mkdir /var/swaptemp
[root@Smoke ~]# dd if=/dev/zero of=/var/swaptemp/swapfile bs=1M count=512
[root@Smoke ~]# mkswap -L SWAP-FILE /var/swaptemp/swapfile
[root@Smoke ~]# swapon /var/swaptemp/swapfile
[root@Smoke ~]# vim /etc/fstab
LABEL=SWAP-FILE         /swap                   swap    defaults        0 0

3、上述第一问，如何让其自动挂载的同时启用ACL功能；

/etc/fstab
LABEL='MYDATA'                /data                ext3                defaults,acl        0 0

压缩、解压缩命令

压缩格式：gz, bz2, xz, zip, Z

压缩算法：算法不同，压缩比也会不同；

compress: FILENAME.Z，压缩，原名称加.点Z，比较古老的压缩方式；

uncompress：解压

XZ,BZ2,GZ：现在流行压缩

gzip: .gz,GZ格式压缩

　　gzip /PATH/TO/SOMEFILE：只能压缩文件，不能压缩目录，压缩完成后会删除原文件，可以指定多个文件，会将每个文件单独压缩；

　　　　-d：解压缩GZ格式文件

　　　　-#：1-9，指定压缩比，默认是6，压缩比越小速度越快，但是压缩完成以后文件越大；

gunzip: 解压GZ格式文件

　　gunzip /PATH/TO/SOMEFILE.gz: 解压完成后会删除原文件；就是压缩文件；

　　zcat /PATH/TO/SOMEFILE.gz： 不解压的情况，查看文本文件的内容，能够临时先找一位置解压出来先查看，当关闭了，临时文件被删除，文件还是压缩的；

bzip2: .bz2,BZ2格式压缩

比gzip有着更大压缩比的压缩工具，使用格式近似

　　bzip2 /PATH/TO/SOMEFILE：只能压缩文件，不能压缩目录，压缩完成后会删除原文件，可以指定多个文件，会将每个文件单独压缩；

　　　　-d：解压BZ2格式文件

　　　　-#: 1-9,指定压缩比，默认是6，压缩比越小速度越快，但是压缩完成以后文件越大；

　　　　-k: 压缩时保留原文件

　　bunzip2 /PATH/TO/SOMEFILE.bz2：解压BZ2格式压缩文件

　　bzcat /PATH/TO/SOMEFILE.bz2：不解压的情况，查看文件的内容，能够临时先找一位置解压出来先查看，当关闭了，临时文件被删除，文件还是压缩的；

xz: .xz,XZ格式压缩

　　xz /PATH/TO/SOMEFILE：只能压缩文件，不能压缩目录，压缩完成后会删除原文件，可以指定多个文件，会将每个文件单独压缩；

　　　　-d：解压XZ格式文件

　　　　-#: 1-9,指定压缩比， 默认是6，压缩比越小速度越快，但是压缩完成以后文件越大；

　　　　-k: --keep 压缩时保留原文件

　　unxz /PATH/TO/SOMEFILE.xz：解压XZ格式压缩文件

　　xzdec /PATH/TO/SOMEFILE.xz：解压XZ格式压缩文件，解压XZ格式文件到屏幕；

　　　　-d：默认动作，解压

　　　　-k：保留原文件

　　　　-c：输入到屏幕上来

　　xzcat /PATH/TO/SOMEFILE.xz：不解压的情况，查看文件的内容，能够临时先找一位置解压出来先查看，当关闭了，临时文件被删除，文件还是压缩的；

提示：这几个压缩命令gzip、bzip2、xz只能压缩文件，不能压缩目录，只能逐个文件进行压缩，如果传递一个目录当作参数的话，它会把目录中的文件逐个进行压缩，不像winrar把目录和里面的文件整体压缩，变成另外一种格式，默认这些命令在压缩完以后会删除原文件，只保留压缩后的文件；
zip: 既归档又压缩的工具，压缩比不大，可以压缩目录，把目录所有文件压缩到一起；

　　zip FILENAME.zip FILE1 FILE2 ...: 压缩后不删除原文件，FILENAME.zip压缩后的文件名，FILE1 FILE2 ...要压缩/归档进来的文件，可以将一堆文件压倒在一起；

　　unzip FILENAME.zip：解压缩文件

archive: 将多个文件压缩在一起，归档，归档本身并不意味着压缩；

tar: 归档工具,只归档不压缩，归档不删除原文件 .tar

　　-c: 创建归档文件

　　-f FILE.tar: 操作的归档文件，要规定的文件名，-f必须放在参数后面

　　-x: 展开归档

　　--xattrs: 归档时，保留文件的扩展属性信息

　　-t: 不展开归档，直接查看归档了哪些文件

　　-v：显示操作过程

　　-C：展开归档文件时，可更改展开路径，默认展开到归档文件目录

问题环境：如果使用tar归档后会使文件变得更大，可以使用xz, bz2, gz文件压缩工具再对归档的文件进行压缩，如果要解压并展开归档需要先通过xz, bz2, gz文件压缩工具对压缩的文件进行解压，然后再通过tar命令进行展开，这样需要两部操作，可以使用tar命令直接调用xz, bz2, gz压缩；

　　-zcf: 归档并调用gzip压缩

　　-zxf: 调用gzip解压缩并展开归档，-z选项可省略

　　-ztf: 不展开归档gzip压缩，直接查看归档压缩了那些文件，-z选项可省略

　　-jcf: 归档并调用bzip2压缩

　　-jxf: 调用bzip2解压缩并展开归档，-j选项可以省略

　　-jtf：不展开归档bzip2压缩，直接查看归档压缩了那些文件，-j选项可省略

　　-Jcf: 归档并调用xz压缩，centos 5x不支持

　　-Jxf: 调用xz解压缩并展开归档，-J选项可以省略

　　-Jtf: 不展开归档xf压缩，直接查看归档压缩了那些文件，-J选项可省略

cpio: 归档工具，把一堆文件做成归档或者从归档当中复制出来文件，跟tar功能相似；

[root@Smoke ~]# cp /var/log/messages ./（复制messages文件到当前目录）
[root@Smoke ~]# ls -lh messages（查看messages文件详细信息，并改变显示文件大小单位)
-rw------- 1 root root 412K Jul 22 23:11 messages
[root@Smoke ~]# gzip messages(将messages文件压缩成gz格式）
[root@Smoke ~]# ls -l(查看当前目录下文件及子目录详细信息，压缩后，原来的messages文件被默认删除）
-rw------- 1 root root 45399 Jul 22 23:11 messages.gz
[root@Smoke ~]# ls -lh messages.gz(查看messages.gz文件详细信息，并改变显示文件大小单位，变为45K）
-rw------- 1 root root 45K Jul 22 23:11 messages.gz
[root@Smoke ~]# gunzip messages.gz（解压GZ格式压缩文件）
[root@Smoke ~]# ls -lh（查看当前目录下文件及子目录，messages解压后的文件，原文件被删除）
-rw------- 1 root root 412K Jul 22 23:11 messages
[root@Smoke ~]# gzip messages(将messages文件压缩为GZ格式文件）
[root@Smoke ~]# ls -lh(查看当前目录下文件及子目录，并改变显示文件大小单位，messages被压缩)
-rw------- 1 root root 45K Jul 22 23:11 messages.gz
[root@Smoke ~]# gzip -d messages.gz(解压GZ格式的messages文件)
[root@Smoke ~]# ls -lh(查看当前目录文件及子目录详细信息，并做单位换算，解压后的message文件）
-rw------- 1 root root 412K Jul 22 23:11 messages
[root@Smoke ~]# gzip -9 messages(压缩messages文件，并指定压缩比例为9）
[root@Smoke ~]# ls -lh messages.gz（查看messages.gz文件详细信息，并做单位换算）
-rw------- 1 root root 44K Jul 22 23:11 messages.gz
[root@Smoke ~]# zcat messages.gz（不解压情况下查看messages.gz压缩文件的内容）
Jul 22 23:05:28 Smoke NetworkManager[1694]: <info>   prefix 24 (255.255.255.0)
Jul 22 23:05:28 Smoke NetworkManager[1694]: <info>   gateway 192.168.226.2
Jul 22 23:05:28 Smoke NetworkManager[1694]: <info>   nameserver '192.168.226.2'
Jul 22 23:05:28 Smoke NetworkManager[1694]: <info>   domain name 'localdomain'
Jul 22 23:05:28 Smoke dhclient[7768]: bound to 192.168.226.132 -- renewal in 806 seconds.
[root@Smoke ~]# bzip2 messages(将messages文件压缩成BZ2格式文件，默认删除原文件）
[root@Smoke ~]# ls -lh messages.bz2(查看messages.bz2文件详细信息，压缩后的messages文件)
-rw------- 1 root root 28K Jul 22 23:11 messages.bz2
[root@Smoke ~]# bzip2 -d messages.bz2(解压messages.bz2格式文件)
[root@Smoke ~]# ls -lh messages(查看解压后的messages文件详细信息，默认删除原文件）
-rw------- 1 root root 412K Jul 22 23:11 messages
[root@Smoke ~]# bzip2 -k messages(将messages文件压缩成BZ2格式文件，-k保留原文件）
[root@Smoke ~]# ls -lh(查看当前目录下文件及子目录详细信息，并做单位换算，压缩后messages原文件被保留）
-rw-------   1 root root  412K Jul 22 23:11 messages
-rw-------   1 root root   28K Jul 22 23:11 messages.bz2
[root@Smoke ~]# bunzip2 messages.bz2（解压messages.bz2文件，默认删除原文件）
[root@Smoke ~]# bzcat messages.bz2（不解压查看BZ2格式压缩文件内容)
Jul 22 23:05:28 Smoke NetworkManager[1694]: <info>   prefix 24 (255.255.255.0)
Jul 22 23:05:28 Smoke NetworkManager[1694]: <info>   gateway 192.168.226.2
Jul 22 23:05:28 Smoke NetworkManager[1694]: <info>   nameserver '192.168.226.2'
Jul 22 23:05:28 Smoke NetworkManager[1694]: <info>   domain name 'localdomain'
Jul 22 23:05:28 Smoke dhclient[7768]: bound to 192.168.226.132 -- renewal in 806 seconds.
[root@Smoke ~]# xz messages(将messages压缩成XZ格式文件，默认删除原文件）
[root@Smoke ~]# ls -lh(查看当前目录下文件及子目录，压缩为XZ格式的压缩文件)
-rw-------   1 root root  412K Jul 22 23:11 messages.bak
-rw-------   1 root root   24K Jul 22 23:11 messages.xz
[root@Smoke ~]# xz -d messages.xz（解压messages.xz格式压缩文件)
[root@Smoke ~]# ls -lh
-rw-------   1 root root  412K Jul 22 23:11 messages
-rw-------   1 root root  412K Jul 22 23:11 messages.bak
[root@Smoke ~]# xz messages(将messages压缩成XZ格式的压缩文件)
[root@Smoke ~]# ls -lh（查看当前目录下文件及子目录详细信息)
-rw-------   1 root root  412K Jul 22 23:11 messages.bak
-rw-------   1 root root   24K Jul 22 23:11 messages.xz
[root@Smoke ~]# xzdec messages.xz(解压messages.xz文件，但是解压是解压到屏幕上)
[root@Smoke ~]# xzdec -dk messages.xz(解压messages文件，-d默认动作解压，-k保留原文件)
[root@Smoke ~]# ls -lh(查看当前目录文件详细信息）
-rw-------   1 root root  412K Jul 22 23:11 messages.bak
-rw-------   1 root root   24K Jul 22 23:11 messages.xz
[root@Smoke ~]# xzdec -dk messages.xz > messages（将解压messages.xz文件的内容输出重定向到messages文件，-d默认解压，-k保留原文件)
[root@Smoke ~]# ls -lh(查看当前目录下文件及子目录详细信息)
-rw-r--r--   1 root root  412K Jul 23 00:11 messages
-rw-------   1 root root  412K Jul 22 23:11 messages.bak
-rw-------   1 root root   24K Jul 22 23:11 messages.xz
[root@Smoke ~]# zip test.zip test/*（将test目录下所有文件压缩成test.zip，默认不会删除原文件)
 adding: test/1xy6 (stored 0%)
 adding: test/a (stored 0%)
 adding: test/a123 (stored 0%)
 adding: test/a b (stored 0%)
 adding: test/ab123 (stored 0%)
 adding: test/abc (stored 0%)
 adding: test/helloy123 (stored 0%)
 adding: test/x12 (stored 0%)
 adding: test/xyz (stored 0%)
 adding: test/xyz123 (stored 0%)
 adding: test/y123 (stored 0%)
[root@Smoke ~]# ls -lh（查看当前目录下文件及子目录详细信息，test.zip压缩的文件)
drwxr-xr-x   2 root root  4.0K Jun  8 00:19 test
-rw-r--r--   1 root root  1.6K Jul 23 22:15 test.zip
[root@Smoke ~]# mv test test.bak（更改test名字为test.bak)[root@Smoke ~]# unzip test.zip(解压test.zip文件，默认不会删除原文件)
Archive:  test.zip
extracting: test/1xy6              
extracting: test/a                  
extracting: test/a123              
extracting: test/a b                
extracting: test/ab123              
extracting: test/abc                
extracting: test/helloy123          
extracting: test/x12                
extracting: test/xyz                
extracting: test/xyz123            
extracting: test/y123  
[root@Smoke ~]# ls -lh(查看当前目录下文件及子目录详细信息，解压后的test目录及子文件，默认zip不会删除原文件)
drwxr-xr-x   2 root root  4.0K Jul 23 22:21 test
drwxr-xr-x   2 root root  4.0K Jun  8 00:19 test.bak
-rw-r--r--   1 root root  1.6K Jul 23 22:15 test.zip
[root@Smoke ~]# cd test(切换到test目录)
[root@Smoke test]# tar -cf test.tar test*.txt(将所有test开头中间任意次数任意字符.txt结尾的文件名归档为test.tar文件，-c创建归档，-f指定规定的文件名）
[root@Smoke test]# ls -lh（查看当前目录下所有文件及子目录，test.tar规定后的文件）
total 12K
-rw-r--r-- 1 root root   0 Jun  6 15:12 1xy6
-rw-r--r-- 1 root root   0 Jun  6 10:48 a
-rw-r--r-- 1 root root   0 Jun  6 10:32 a123
-rw-r--r-- 1 root root   0 Jun  6 15:20 a b
-rw-r--r-- 1 root root   0 Jun  6 10:32 ab123
-rw-r--r-- 1 root root   0 Jun  6 10:32 abc
-rw-r--r-- 1 root root   0 Jun  6 14:53 helloy123
-rw-r--r-- 1 root root   0 Jul 23 22:29 test2.txt
-rw-r--r-- 1 root root   0 Jul 23 22:29 test3.txt
-rw-r--r-- 1 root root   0 Jul 23 22:29 test6.xtx
-rw-r--r-- 1 root root 10K Jul 23 22:29 test.tar
-rw-r--r-- 1 root root   0 Jul 23 22:29 test.txt
-rw-r--r-- 1 root root   0 Jun  6 10:32 x12
-rw-r--r-- 1 root root   0 Jun  6 10:32 xyz
-rw-r--r-- 1 root root   0 Jun  6 10:32 xyz123
-rw-r--r-- 1 root root   0 Jun  6 14:54 y123
[root@Smoke test]# rm -rf test*.txt（删除所有test开始中间任意字符.txt结尾的文件，-r删除目录，-f强制删除，不提示）
[root@Smoke test]# tar -xf test.tar(展开归档的test.tar文件，-x展开归档，-f要操作的文件）
[root@Smoke test]# ls -lh（查看当前目录下文件及子目录详细信息，解压后的test.tar文件）
total 12K
-rw-r--r-- 1 root root   0 Jun  6 15:12 1xy6
-rw-r--r-- 1 root root   0 Jun  6 10:48 a
-rw-r--r-- 1 root root   0 Jun  6 10:32 a123
-rw-r--r-- 1 root root   0 Jun  6 15:20 a b
-rw-r--r-- 1 root root   0 Jun  6 10:32 ab123
-rw-r--r-- 1 root root   0 Jun  6 10:32 abc
-rw-r--r-- 1 root root   0 Jun  6 14:53 helloy123
-rw-r--r-- 1 root root   0 Jul 23 22:29 test2.txt
-rw-r--r-- 1 root root   0 Jul 23 22:29 test3.txt
-rw-r--r-- 1 root root   0 Jul 23 22:29 test6.xtx
-rw-r--r-- 1 root root 10K Jul 23 22:29 test.tar
-rw-r--r-- 1 root root   0 Jul 23 22:29 test.txt
-rw-r--r-- 1 root root   0 Jun  6 10:32 x12
-rw-r--r-- 1 root root   0 Jun  6 10:32 xyz
-rw-r--r-- 1 root root   0 Jun  6 10:32 xyz123
-rw-r--r-- 1 root root   0 Jun  6 14:54 y123
[root@Smoke test]# tar -tf test.tar（不展开归档查看test.tar规定文件有那些文件，-t不展开规定查看规定文件中的文件，-f要操作的文件）
test2.txt
test3.txt
test.txt
[root@Smoke test]# xz test.tar(对test.tar归档文件进行XZ格式压缩）
[root@Smoke test]# ls（压缩后的test.tar归档文件）
1xy6  a123  ab123  helloy123  test3.txt  test.tar.xz  x12  xyz123
a     a b   abc    test2.txt  test6.xtx  test.txt     xyz  y123
[root@Smoke test]# xz -d test.tar.xz（解压XZ格式文件)
[root@Smoke test]# tar xf test.tar(再解压)
[root@Smoke test]# tar --version（查看tar命令版本）
tar (GNU tar) 1.23
Copyright (C) 2010 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later < http://gnu.org/licenses/gpl.html >.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Written by John Gilmore and Jay Fenlason.
[root@Smoke test]# tar -jcf test.tar.bz2 test*.txt(将test开头中间任意字符.txt结尾的文件归档并调用bzip2压缩）
[root@Smoke test]# ls -lh（查看归档并使用bzip2压缩后的test.tar.bz2文件)
total 8.0K
-rw-r--r-- 1 root root   0 Jun  6 15:12 1xy6
-rw-r--r-- 1 root root   0 Jun  6 10:48 a
-rw-r--r-- 1 root root   0 Jun  6 10:32 a123
-rw-r--r-- 1 root root   0 Jun  6 15:20 a b
-rw-r--r-- 1 root root   0 Jun  6 10:32 ab123
-rw-r--r-- 1 root root   0 Jun  6 10:32 abc
-rw-r--r-- 1 root root   0 Jun  6 14:53 helloy123
-rw-r--r-- 1 root root   0 Jul 23 22:29 test2.txt
-rw-r--r-- 1 root root   0 Jul 23 22:29 test3.txt
-rw-r--r-- 1 root root   0 Jul 23 22:29 test6.xtx
-rw-r--r-- 1 root root 145 Jul 23 23:03 test.tar.bz2
-rw-r--r-- 1 root root 196 Jul 23 23:00 test.tar.xz
-rw-r--r-- 1 root root   0 Jul 23 22:29 test.txt
-rw-r--r-- 1 root root   0 Jun  6 10:32 x12
-rw-r--r-- 1 root root   0 Jun  6 10:32 xyz
-rw-r--r-- 1 root root   0 Jun  6 10:32 xyz123
-rw-r--r-- 1 root root   0 Jun  6 14:54 y123
[root@Smoke test]# tar -jxf test.tar.bz2(展开test.tar.bz2归档bzip2压缩文件）
[root@Smoke test]# tar -jtf test.tar.bz2(不展开归档bzip2压缩直接查看里面的文件）
test2.txt
test3.txt
test.txt
[root@Smoke test]# file /boot/initramfs-2.6.32-431.el6.x86_64.img(查看initramfs文件类型）
/boot/initramfs-2.6.32-431.el6.x86_64.img: gzip compressed data, from Unix, last modified: Mon Apr 14 01:15:58 2014, max compression
[root@Smoke test]# cp /boot/initramfs-2.6.32-431.el6.x86_64.img /root/（复制initramfs文件到/root目录)
[root@Smoke ~]# mv initramfs-2.6.32-431.el6.x86_64.img initramfs-2.6.32-431.el6.x86_64.img.gz(重命名initramfs为initramfs.gz)
[root@Smoke ~]# gzip -d initramfs-2.6.32-431.el6.x86_64.img.gz(使用gz类型解压initramfs.gz文件）
[root@Smoke ~]# file initramfs-2.6.32-431.el6.x86_64.img（查看initramfs文件类型为ASCII cpio归档的文件)
initramfs-2.6.32-431.el6.x86_64.img: ASCII cpio archive (SVR4 with no CRC)

练习：写一个脚本

从键盘让用户输入几个文件，脚本能够将此几个文件归档压缩成一个文件；

read:能够跟用户进行交互，能够让我们通过键盘输入数据并保存在某个变量里面，可以读取多个变量的值，变量和输入的值都需要使用空格隔开；如果给的数据个数和变量个数一样，数据和变量一对一，如果给的数据个数多于变量格式，第一个数据给第一个变量，最后剩下的都给最后一个变量，如果数据个数少于变量个数，第一个变量对应第一个数据，后面的变量数据会为空；

　　-p "PROMPT": 给出提示，可以代替echo直接说明要做的事情；

　　-t #：指定超时时间，等待用户输入，如果不输入多长时间超时，默认单位秒；

[root@Smoke ~]# read NAME（从键盘读取变量值abc)
abc
[root@Smoke ~]# echo $NAME(显示变量NAME的值)
abc
[root@Smoke ~]# read NAME(从键盘读取变量值abc def)
abc def
[root@Smoke ~]# echo $NAME(显示变量NAME的值)
abc def
[root@Smoke ~]# read NAME AGE(从键盘读取变量值jerry 18)
jerry 18
[root@Smoke ~]# echo $NAME(显示变量NAME的值)
jerry
[root@Smoke ~]# echo $AGE(显示变量AGE的值)
18
注意:可以读取多个变量的值，变量和输入的值都需要使用空格隔开
[root@Smoke ~]# read NAME AGE(从键盘读取变量值jerry 18 66 99)
jerry 18 66 99
[root@Smoke ~]# echo $NAME(显示变量NAME的值)
jerry
[root@Smoke ~]# echo $AGE(显示变量AGE的值）
18 66 99
注意：如果变量个数少于输入值的个数，变量从前到后以此赋予值，前面一对一赋值，后面的变量可能多个值
[root@Smoke ~]# read NAME AGE(从键盘读取变量值jerry)
jerry
[root@Smoke ~]# echo $NAME(显示变量NAME值)
jerry
[root@Smoke ~]# echo $AGE(显示变量AGE值)
注意：如果变量个数多于输入值的个数，变量从前到后依次赋值，后面的变量值可能为空
脚本：输入任意两个数计算两个数之和
[root@Smoke ~]# vim sum1.sh（编辑sum.sh脚本)
#!/bin/bash
#
echo "Input tow intergers:"
read A B
echo $[$A+$B]
[root@Smoke ~]# chmod +x sum1.sh(给sum1.sh文件执行权限）
[root@Smoke ~]# ./sum1.sh(当前目录执行sum1.sh文件）
Input tow intergers:
2 3
5
[root@Smoke ~]# vim sum1.sh(编辑sum1.sh文件)
#!/bin/bash
#
echo -n "Input tow intergers:"（-n:不换行)
read A B
echo "$A plus $B is: $[$A+$B]"
[root@Smoke ~]# ./sum1.sh(当前目录执行sum1.sh文件)
Input tow intergers:4 6
4 plus 6 is: 10
[root@Smoke ~]# vim sum1.sh(编辑sum1.sh)
#!/bin/bash
#
#echo -n "Input tow intergers:"(注释掉echo提示）
read -p "Input tow Intergers:" A B(使用read -p可以直接键入提示的内容）
echo "$A plus $B is: $[$A+$B]"
[root@Smoke ~]# ./sum1.sh
Input tow Intergers:6 8
6 plus 8 is: 14
[root@Smoke ~]# vim sum1.sh(编辑sum1.sh)
#!/bin/bash
#
#echo -n "Input tow intergers:"
read -t 5 -p "Input tow Intergers:" A B(read -t指定超时时间为5秒，5秒后超时A和B的值为空，判断变量A和B是否为空，如果为空给A和B赋值为100和1000）
[ -z $A ] && A=100
[ -z $B ] && B=1000
echo "$A plus $B is: $[$A+$B]"
[root@Smoke ~]# ./sum1.sh(当前目录执行sum1.sh文件，5秒超时自动赋予默认值计算）
Input tow Intergers:100 plus 1000 is: 1100
[root@Smoke ~]# vim sum1.sh（编辑sum1.sh文件）
#!/bin/bash
#
#echo -n "Input tow intergers:"
read -t 5 -p "Input tow Intergers[100 and 1000]:" A B
[ -z $A ] && A=100
[ -z $B ] && B=1000
echo "$A plus $B is: $[$A+$B]"
[root@Smoke ~]# ./sum1.sh(当前目录执行sum1.sh文件）
Input tow Intergers[100 and 1000]:5 7
5 plus 7 is: 12
脚本：输入三个文件对文件进行归档
[root@Smoke ~]# vim myar.sh(编辑myar.sh）
#!/bin/bash
#
read -p "Three files:" FILE1 FILE2 FILE3(输入三个文件路径和文件名)
read -p "Destination:" DEST(输入归档后的路径和文件名）
tar -jcf $DEST.tar.bz2 $FILE1 $FILE2 $FILE3(对文件进行归档bz2类型压缩)
[root@Smoke ~]# chmod +x myar.sh(给myar.sh执行权限）
[root@Smoke ~]# ./myar.sh(当前目录执行myar.sh文件）
Three files:test/test.txt test/test2.txt test/test6.txt
Destination:test/myartest
[root@Smoke ~]# ls test -lh（查看test目录下文件及子目录详细信息，归档的myartest.tar.bz2文件）
-rw-r--r-- 1 root root 153 Jul 24 22:55 myartest.tar.bz2
-rw-r--r-- 1 root root 0 Jul 23 22:29 test2.txt
-rw-r--r-- 1 root root 0 Jul 23 22:29 test3.txt
-rw-r--r-- 1 root root 0 Jul 24 22:54 test6.txt
-rw-r--r-- 1 root root 0 Jul 23 22:29 test6.xtx
-rw-r--r-- 1 root root 145 Jul 23 23:03 test.tar.bz2
-rw-r--r-- 1 root root 196 Jul 23 23:00 test.tar.xz
-rw-r--r-- 1 root root 0 Jul 23 22:29 test.txt
[root@Smoke ~]# tar -tf test/myartest.tar.bz2(不解压文件查看文件内容)
test/test.txt
test/test2.txt
test/test6.txt
#!/bin/bash
#
read -p "Three files:" FILE1 FILE2 FILE3
read -p "Destination:" DEST
read -p "Compress[gzip|bzip2|xz]:" COMP
#!/bin/bash
#
read -p "Three files:" FILE1 FILE2 FILE3
read -p "Destination:" DEST
read -p "Compress[gzip|bzip2|xz]:" COMP
case $COMP in
gzip)
tar -zcf ${DEST}.tar.gz $FILE1 $FILE2 $FILE3
;;
#
read -p "Three files:" FILE1 FILE2 FILE3
read -p "Destination:" DEST
read -p "Compress[gzip|bzip2|xz]:" COMP
case $COMP in
gzip)
tar -zcf ${DEST}.tar.gz $FILE1 $FILE2 $FILE3
;;
bzip2)
tar -jcf $DEST.tar.bz2 $FILE1 $FILE2 $FILE3
;;
xz)
tar -cf ${DEST}.tar $FILE1 $FILE2 $FILE3
xz ${DEST}.tar
;;
*)
echo "Unkown."
exit 9
;;
esac
[root@Smoke ~]# ./myar.sh(当前目录执行myar.sh文件）
Three files:test/test.txt test/test2.txt test/test6.txt
Destination:test/myartest2
Compress[gzip|bzip2|xz]:gzip
[root@Smoke ~]# ls -l test(查看test目录下文件及子目录详细信息myartest2.tar.gz压缩的文件）
-rw-r--r-- 1 root root 150 Jul 24 23:13 myartest2.tar.gz
-rw-r--r-- 1 root root 153 Jul 24 22:55 myartest.tar.bz2
-rw-r--r-- 1 root root 0 Jul 23 22:29 test2.txt
-rw-r--r-- 1 root root 0 Jul 23 22:29 test3.txt
-rw-r--r-- 1 root root 0 Jul 24 22:54 test6.txt
-rw-r--r-- 1 root root 0 Jul 23 22:29 test6.xtx
-rw-r--r-- 1 root root 145 Jul 23 23:03 test.tar.bz2
-rw-r--r-- 1 root root 196 Jul 23 23:00 test.tar.xz
-rw-r--r-- 1 root root 0 Jul 23 22:29 test.txt

脚本编程：

　　顺序结构

　　选择结构

　　　　if

　　　　case

　　循环结构

　　　　for

　　　　while

　　　　until

while循环：适用于循环次数未知的场景，要有退出条件

语法：

　　while CONDITION(满足条件); do(循环)

　　　　statement(执行语句)

　　　　...

　　done(结束)

计算100以内所有正整数的和

#!/bin/bash
declare -i I=1
declare -i SUM=0
while [ $I -le 100 ]; do
 let SUM+=$I
 let I++
done
echo $SUM

[root@Smoke ~]# vim while.sh(编辑while.sh文件)
#!/bin/bash
#
declare -i I=1
declare -i SUM=0
while [ $I -le 100 ];do
       let SUM+=$I
       let I++
done
echo $SUM
[root@Smoke ~]# chmod +x while.sh(给while.sh文件执行权限)
[root@Smoke ~]# ./while.sh(当前目录执行while.sh文件)
5050

练习：转换用户输入的字符为大写，除了quit:

#!/bin/bash
#
read -p "Input something: " STRING
while [ $STRING != 'quit' ]; do
 echo $STRING | tr 'a-z' 'A-Z'
 read -p "Input something: " STRING
done

[root@Smoke ~]# vim translate.sh(编辑translate.sh文件）
#!/bin/bash
#
read -p "Input something:" STRING
while [ $STRING != 'quit' ];do（STRING不等于quit就执行循环，将小写转换为大写，让再输入，如果输入quit就退出)
       echo $STRING | tr 'a-z' 'A-Z'
       read -p "Input something:" STRING
done
[root@Smoke ~]# chmod +x translate.sh(给translate.sh文件执行权限）
[root@Smoke ~]# ./translate.sh(当前目录执行translate.sh文件）
Input something:abc
ABC
Input something:hello
HELLO
Input something:quit

练习：每隔5秒查看hadoop用户是否登录，如果登录，显示其登录并退出；否则，显示当前时间，并说明hadoop尚未登录：

#!/bin/bash
#
who | grep "hadoop" &> /dev/null
RETVAL=$?
while [ $RETVAL -ne 0 ]; do
 echo "`date`, hadoop is not log."
 sleep 5
 who | grep "hadoop" &> /dev/null
 RETVAL=$?
done
echo "hadoop is logged in."

[root@Smoke ~]# vim detecthadoop.sh(编辑detecthadoop.sh文件)
#!/bin/bash
#
who | grep "hadoop" &> /dev/null
RETVAL=$?(将上一个命令执行状态返回值赋予RETVAL变量)
while [ $RETVAL -ne 0 ];do(判断状态返回值是否不等于0，不等于为真执行循环)
       echo "`date`,hadoop is not log."
       sleep 5(间隔5秒)
       who | grep "hadoop" &> /dev/null
       RETVAL=$?
done
echo "hadoop is logged in."
[root@Smoke ~]# chmod +x detecthadoop.sh(给detecthadoop.sh执行权限)
[root@Smoke ~]# ./detecthadoop.sh(当前目录执行detecthadoop.sh文件)
Fri Jul 25 00:01:57 CST 2014,hadoop is not log.
Fri Jul 25 00:02:02 CST 2014,hadoop is not log.
hadoop is logged in.