精华内容
下载资源
问答
  • 1 Linux中的文件1.1 文件属性概述Linux系统中的文件或目录的属性主要包括:索引节点(inode)、文件类型、权限属性、链接数、所归属的用户和用户组、最近修改时间等内容。[root@oldboy ~]# ls -lhi total 36K ...

    1 Linux中的文件

    1.1 文件属性概述

    Linux系统中的文件或目录的属性主要包括:索引节点(inode)、文件类型、权限属性、链接数、所归属的用户和用户组、最近修改时间等内容。

    [root@oldboy ~]# ls -lhi
    
    total 36K
    
    390149 -rw-r--r--. 1 root root 22K Nov 16 11:33 install.log
    
    390150 -rw-r--r--. 1 root root 5.8K Nov 16 11:30 install.log.syslog
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    ls -lhi共显示10列内容,分别介绍所指内容:

    2 索引节点inode

    inode 中文意思是索引节点(index node)。在每个Linux存储设备或存储设备的分区(存储设备可以是硬盘、软盘、U盘……)被格式化为ext4(Centos6.7)文件系统,一般生成两部分:第一部分是Inode(很多个),第二部分是Block(很多个)。

    Block 是用来存储实际数据用的,例如:照片、视频等普通文件数据。

    而Inode就是用来存储这些数据属性信息的(也就是ls -l的结果),inode属性信息包括不限于问价大小、属主(用户)、归属的用户组、文件权限、文件类型、修改时间,还包含指向文件实体的指针的功能(inode节点–block的对应关系)等,但是,inode里面唯独不包含文件名,文件名一般在上级目录的block里。

    Inode除了记录文件属性的信息外,还会为每个文件进行信息索引,所以就有了inode的数值。操作系统根据指令,即可通过inode的值最快的找到相对应的文件实体。文件,inode,block 之间的关系见下图:

    这里写图片描述

    #stat 显示文件和文件系统状态(查看文件属性)
    
    [root@oldboy test]# stat file1.txt
    
    File: `file1.txt'
    
    Size: 0 Blocks: 0 IO Block: 4096 regular empty file
    
    Device: 803h/2051d Inode: 140162 Links: 1
    
    Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
    
    Access: 2017-12-15 07:31:09.754991273 -0500
    
    Modify: 2017-12-15 07:31:09.754991273 -0500
    
    Change: 2017-12-15 07:31:09.754991273 -0500
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    因为inode 要存放文件的属性信息,所以每个inode 本身是有大小的,Centos5系列inode的默认大小是128 字节,而Centos6系列inode 的默认大小是256 字节,inode的大小在分区被格式化创建文件系统之后定下来,被格式化之后就无法更改inode的大小了,格式化前可以通过参数指定inode大小,但是一般企业工作环境没这个需求。

    dumpe2fs /dev/sda*:可以查看指定分区的

    #用grep加 -i 选项不区分大小写检索

    [root@oldboy ~]# dumpe2fs /dev/sda1 | grep -i "inode size"
    
    dumpe2fs 1.41.12 (17-May-2010)
    
    Inode size: 128
    
    [root@oldboy ~]# dumpe2fs /dev/sda3 | grep -i "inode size"
    
    dumpe2fs 1.41.12 (17-May-2010)
    
    Inode size: 256
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    查看文件系统inode总量以及剩余量

    [root@oldboy ~]# df -i
    
    Filesystem Inodes IUsed IFree IUse% Mounted on
    
    /dev/sda3 593344 55756 537588 10% /
    
    tmpfs 125514 1 125513 1% /dev/shm
    
    /dev/sda1 51200 38 51162 1% /boot
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    文件系统 inode节点数 已使用数 剩余数 已使用百分比 挂载点

    查看磁盘的使用量

    [root@oldboy ~]# df -h
    
    Filesystem Size Used Avail Use% Mounted on
    
    /dev/sda3 8.8G 1.5G 6.9G 18% /
    
    tmpfs 491M 0 491M 0% /dev/shm
    
    /dev/sda1 190M 35M 146M 19% /boot
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    磁盘空间是否满了,是由两项参数决定的:第一个是inode是否满了,第二个block是否满了,任何一项满了,磁盘就不能再放东西了。

    2.1 有关inode的小结

    1) 磁盘被分区并格式化为ext4 文件系统后会生成一定数量的inode 和block。

    2) inode 称为索引节点,它的作用是存放文件的属性信息以及作为文件的索引(指向文件的实体)。

    3) ext3/ext4 文件系统的block 存放的是文件的实际内容。

    4) inode 是磁盘上的一块存储空间,Centos6 非启动分区inode默认大小256 字节,Centos5 是128 字节。

    5) inode 的表现形式是一串数字,不同的文件对应的inode(一串数字) 在文件系统里是唯一的。

    6)inode 节点号相同的文件,互为硬连接文件,可以认为是一个文件的不同入口。

    7) ext3/ext4文件系统下,一个文件在创建后至少要占用一个indoe和一个block

    8) ext3/ext4文件系统下,正常情况下一个文件占用且只能占用一个indoe(人和身份证)

    9) block是用来存储实际数据的,它的大小一般有1k,2k,3k几种。其中引导分区等为1k,其他普通分区多为4k(Centos6)

    10) 如果一个文件很大(4G),可能站多个block;如果文件很小(0.01k),至少占一个block,并且这个block的剩余空间浪费了,即无法再存储其它数据

    11) inode大小和总量查看

    [root@oldboy ~]# dumpe2fs /dev/sda3|egrep -i “block size|Inode size”

    dumpe2fs 1.41.12 (17-May-2010)

    Block size: 4096

    Inode size: 256

    [root@oldboy ~]# dumpe2fs /dev/sda3|egrep -i “block count|Inode count”

    dumpe2fs 1.41.12 (17-May-2010)

    Inode count: 593344

    Block count: 2373376

    Reserved block count: 118668

    默认一般情况下Block数量大于inode数量

    12) 查看inode的总量和使用命令df -i

    13) 查看文件的inode:

    ls -i or stat filename

    14) 如何生成及制定inode大小 
    格式化命令:mkfs.ext4 -b 2048 -I 256 /dev/sdb

    2.2 有关Block的知识小结

    1) 磁盘读取数据是按blbck 为单位读取的。

    2) 一个文件可能占用多个block。但是每读取一个block就会消耗一次磁盘I/O。

    3) 如果要提升磁盘IO 性能,那么尤要尽可能一次性读取数据尽量的多。

    4) 一个block 只能存放一个文件的内容,无论内容有多小。如果block 4K,那存放1K 的文件,剩余3K就浪费了。

    5) Block 并非越大越好。Block 太大对于小文件存放就会浪费磁盘空间,例如:1000K的文件,BLOCK 大小为4K,占用250 个BLOCK;若BLOCK 为IK,要占1000个BLOCK。访问效率谁更高? 消耗IO 分别为250 次和1000 次。

    6) 根据业务需求,确定默认的block 大小,如果是大文件( 大于16K)一般设置block 大一点,小文件(小于1K)一般设置block小一点。

    7) BLOCK 太大,例如4K,文件都是0.1K的,大量浪费磁盘空间,但是访问性能高。

    8) BLOCK 太小,例如1K,文件都是1000K,消耗大量磁盘IO。

    8) BLOCK 的设置也是格式化分区的对候,mkfs.ext4-b 2048-I 256 /dev/sdb

    9) 文件较大时,block 设置大一些会提升磁盘访问效率。

    10) 企业里的文件都会比较大(一般都会大于4K),block设置大一些会提升磁盘访问效率。

    11) ext3/ext4文件系统(Centos5和6),一般都设置为4K。

    2.3 可以用inode删除文件

    [root@oldboy test]# ll -i file1.txt
    
    140162 -rw-r--r--. 1 root root 0 Dec 15 07:31 file1.txt
    
    [root@oldboy test]# rm `find . -inum 140162`
    
    [root@oldboy test]# find . -inum 140162 -exec rm {} \;
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    文件删除备份ext3grep

    2.4 企业面试题1

    一个100M(100000K)的磁盘分区,分别写入1K的文件或写入1M的文件,分别可以写都少个?

    假设B 4K 写入1k文件的数量基本上就是block数量

    假设 inode 数量够多的时候,就是BLOCK的数量。浪费3/4的容量。

    假设 inode 数量小于block的数量,就是inode的数量。浪费3/4的容量。

    假设B 4K 写入1M的文件

    总block数量/250block=存放1M的数量

    硬盘空间多大,基本上就可以写入100/1M数量,一般情况inode和block都是做够。

    正确答案:

    1、默认分区常规情况下,对大文件来讲inode是够的。而block数量消耗的会更快,BLOCK为4K的情况,1M的文件不会有磁盘浪费情况,所以文件数量大概为100/1=100 个。

    2、对于小文件0.1k,inode会消耗的更快。默认分区的时候block数量是大于inode数量的。每个小文件都会占用一个inode和一个block.所以最终文件的数量:

    Inode会先消耗完,文件总量是inode的数量。

    a.上面的考试题考察的是文件系统inode和block的知识。

    b.Inode是存放文件属性信息的(也包含指向文件实体的指针).默认大小128byte(c58),256byte(c64).

    c.Block 是存放文件实际内容的,默认大小1K (boot)或4K(非系统分区默认给4K),一般企业多用4K 的 block.

    d.一个文件至少要占用一个inode及一个block。

    e.默认较大分区常规企业真实场景情况下,inode数量是足够的。而block数量消耗的会更快。

    2.5 企业面试题2

    如果向磁盘写入数据提示如下错误:No space left on device,通过df -h查看磁盘空间,发现没满,请问可能是什么原因?企业场景什么情况下会导致这个问题发生呢?

    解答:可能是inode数量倍消耗尽了。发生的原因就是小文件特别(如/var/spool/clientmquene这里很容易被大量小文件占满导致No space left on device的错误。而这个目录只有安装了sendmail服务才会有,是sendmail邮件的临时队列。centos5.8默认会安装sendmail服务,而centos6.6默认没有sendmail服务,但是有postfix。)

    3 Linux文件类型及扩展名

    3.1 文件类型介绍

    Linux系统不同于windows系统,两者之间的文件类型和文件扩展名也有很大的差异,两者之间所代表的含义不同。

    例如:

    windows下文件扩展名:.jpg、.txt、.doc、.pdf、.gif、.exe、.bat等等。

    Linux下的文件类型却和扩展名没什么关系。

    3.2 文件类型

    在Linux系统中,可以说是一切(包括目录、普通文件)皆为文件。文件类型包含有普通文件(-)、目录(d)、字符设备文件(c)、块设备文件(b)、符号链接文件(l)、管道文件(p)等等。

    1 .tar、.tar.gz、.tgz、.zip、.tar.bz 
    表示压缩文件,创建命令一般为tar,gzip,unzip等

    2 .sh 表示shell 脚本文件,通过shell 语言开发的程序。

    3 .pl 表示perl 语言文件,通过perl 语言开发的程序。

    4 .py 表示python 语言文件,通过python 语言开发的程序。

    5 .html、.htm、.php、.jsp、.do 表示网页语言的文件。

    6 .conf 表示系统的配置文件。

    7 .rpm 表示rpm安装包文件。

    可用ls -l 来查看。

    [root@oldboy test]# ls -l
    
    total 4
    
    crw-rw-rw-. 1 root root 1, 5 Nov 21 09:53 character
    
    drwxr-xr-x. 2 root root 4096 Dec 15 07:31 dir
    
    -rw-r--r--. 1 root root 0 Dec 15 16:34 file
    
    lrwxrwxrwx. 1 root root 4 Dec 15 16:34 link -> file
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    3.2.1 普通文件(-)

    创建: touch、cp、tar、echo、cat、>、>>等工具。

    删除: 可用rm命令。

    按照内容,有大致可分为三种

    1)、纯文本(ascii):文件内容可以直接督导数据,例如:字母、数字、特殊字符串等。可以用cat命令读文件,比如配置文件几乎都是这种类型的。

    2)、二进制文件(binary):Linux中的命令程序都是属于这种格式。例如cat命令就是一个二进制文件。

    3)、数据格式文件(data) 
    有些程序在运行的过程中会读取某些特定格式的文件,那些特定格式的文件可以被称为数据文件。 
    例如:linux 在用户登录时,都会将登录的数据记录在/var/1og/wtmp(last命令的数据库文件)那个文件内,该文件是一个数据文件。通过last命令读出来。cat命令会读出乱码。因为他属于一种特殊格式的文件。lastlog(/var/log/lastlog)

    PS:通过file命令可以查看文件类型。

    通过file命令可以查看文件类型

    [root@oldboy test]# file file
    
    file: ASCII text
    
    [root@oldboy test]# file /var/log/lastlog
    
    /var/log/lastlog: data
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3.2.2 目录文件(directory)

    创建: mkdir、cp

    删除: rmdir、rm -r

    ls -F或ls -p来区分目录

    [root@oldboy test]# ls -F
    
    character dir/ file link@
    
    [root@oldboy test]# ls -p
    
    character dir/ file link
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3.2.3 字符设备或块设备文件(character/block)

    进入/dev目录下查看一个字符文件

    [root@oldboy dev]# ll tty
    
    crw-rw-rw-. 1 root tty 5, 0 Nov 21 09:53 tty
    
    • 1
    • 2
    • 3
    • 4

    进入/dev目录下查看一个块设备文件

    [root@oldboy dev]# find /dev/ -type b | xargs ls -l
    
    brw-rw----. 1 root disk 8, 1 Nov 22 06:31 sda1
    
    brw-rw----. 1 root disk 8, 2 Nov 21 09:53 sda2
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    字符设备和块设备一般都在/dev/目录下,块设备就是存放数据的,如/dev/sda等创建字符文件和块设备文件(不重要,了解即可)

    [root@oldboy test]# mknod oldboy c 5 1
    
    [root@oldboy test]# mknod oldboy1 b 5 1
    
    [root@oldboy test]# ll oldboy *
    
    crw-r--r--. 1 root root 5, 1 Dec 15 17:46 oldboy
    
    brw-r--r--. 1 root root 5, 1 Dec 15 17:46 oldboy1
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    3.2.4 套接字文件(socket)

    套接字文件也是一类特殊的文件,这类文件通常用在网络之间进行数据连接,如:我们可以启动一个城西来监听客户端的请求,客户端可以通过套接字来进行数据通信。简单了解即可。

    查找一个套接字文件

    [root@oldboy ~]# find / -type s | xargs ls -l
    
    srw-rw-rw-. 1 root root 0 Nov 21 09:53 /dev/log
    
    • 1
    • 2
    • 3
    • 4

    3.2.5 符号链接文件(link)

    符号链接文件也被称之为软连接文件

    查找链接文件

    [root@oldboy test]# ll link
    
    lrwxrwxrwx. 1 root root 4 Dec 15 16:34 link -> file
    
    #/etc/rc.d/init.d和/etc/init.d这两个文件是一个文件
    
    [root@oldboy test]# ll /etc/rc.d/init.d /etc/init.d -d
    
    lrwxrwxrwx. 1 root root 11 Nov 16 11:27 /etc/init.d -> rc.d/init.d
    
    drwxr-xr-x. 2 root root 4096 Dec 15 06:31 /etc/rc.d/init.d
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    可用ln -s创建软连接文件

    [root@oldboy test]# ln -s file link
    
    • 1
    • 2

    3.2.6 管道文件(FIFO.pipo)

    FIFO也是一个特殊的文件类型,主要是解决多个程序同时访问一个文件所造成的错误,第一个字符为p。FIFO是fifo–>first-in first-out的缩写。

    [root@oldboy ~]# find / -type p | xargs ls -l
    
    prw--w--w-. 1 postfix postfix 0 Dec 15 17:59 /var/spool/postfix/public/pickup
    
    prw--w--w-. 1 postfix postfix 0 Dec 15 17:57 /var/spool/postfix/public/qmgr
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    4 Linux文件的权限

    这里写图片描述

    r read(读) 4
    
    w write (写) 2
    
    x execute (执行) 1
    
    -   没有权限 0
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    这9个,三位一组,第一组为属主的权限,用户权限位、第二组为属组权限位、第三组为其他用户的权限位。

    5 Linux软硬链接知识

    5.1 链接的概念

    在Linux系统中,链接可分为两种:一种为硬链接(HardLink),另一种为软连接或符号链接(Symbolic Link or Soft Link)。ln直接创建的为硬链接,加-s参数创建的链接为软连接。

    格式:

    **硬链接:**ln 源文件 目标文件

    **软连接:l**n -s 源文件 目标文件(目标文件不能事先存在)

    5.2 硬链接

    硬链接是指通过索引节点(Inode)来进行链接。在Linux文件系统中,多个文件名指向同一个索引节点(Inode)是正常且允许的这种情况的文件就称为硬链接。提示:硬链接文件就相当于文件的另外一个入口。硬链接的作用之一是允许一个文件拥有多个有效路径名(多个入口),这样用户就可以建立硬链接到重要的文件,以防止“误删”源数据(很多硬件存储,如netapp存储中的快照功能就应用了这个原理,增加一个快照就多了一个硬链接)。为什么一个文件建立了硬链接就会防止数据误删呢?

    因为文件系统(ext2) 的原理是,只要文件的索引节点(Inode Index)还有一个以上的硬链接。只删除其中一个硬链接(即仅仅删除了该文件的链接指向)并不影响索引节点本身和其它的链接(即数据文件实体并未被删除),只有当文件的最后一个链接被删除后,此时如果有新数据要存储到硬盘上时或者系统通过类似fsck做磁盘检查的时候。被删除文件的数据块及目录的链接才会被释放,空间被新数据占用并覆盖。此时,数据就再也无法找回了。也就是说,在linux系统中,删除静态文件(没有进程调用) (目录也是文件)的条件是与之相关的所有硬链接文件均被删除。

    [root@oldboy test]# echo 1 > a
    
    [root@oldboy test]# cat a
    
    1
    
    [root@oldboy test]# ll a
    
    -rw-r--r--. 1 root root 2 Dec 15 19:25 a
    
    [root@oldboy test]# ln a b
    
    [root@oldboy test]# ll a
    
    -rw-r--r--. 2 root root 2 Dec 15 19:25 a
    
    [root@oldboy test]# ll -i a b
    
    140170 -rw-r--r--. 2 root root 2 Dec 15 19:25 a
    
    140170 -rw-r--r--. 2 root root 2 Dec 15 19:25 b
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    5.2.1 硬链接知识小结

    1、具有相同inode 节点号的多个文件是互为硬链接文件。

    2、删除硬链接文件或者删除源文件任意之一,文件实体并未被删除。

    3、只有删除了源文件及所有对应的硬链接文件,文件实体才会被删除。

    4、当所有的硬链接文件及源文件被删除后,再存放新的数据会占用这个文件的空间,或者磁盘fsck检查的时候,删除的数据也会被系统回收。(养成删除及多套环境测试的好习惯)。

    5、硬链接文件就是文件的另一个入口(相当于超市的前门、后门一样)。

    6、可以通过给文件设置硬链接文件,来防止重要文件被误删。

    7、通过执行命令“1n 源文件 硬链接文件”,即可完成创建硬链接。

    8、硬链接文件可以用rm命令删除。

    9、对于静态文件(没有进程正在调用的文件)来讲,当对应硬链接数为0(i_link),文件就被删除。i_link的查看方法(1s -1结果的第三列就是)

    5.3 软链接

    软链接(Soft Link)也称为符号链接(Symbolic Link)。Linux里的软链接文件类似于Windows系统里的快捷方式。Linux里的软链接文件实际上是一个特殊的文件,文件类型是 l。软链接文件实际上可以理解为一个文本文件,这个文件中包含有软链接指向另一源文件的位置信息内容,因此,通过访问这个“快捷方式”就可以迅速定位到软链接所指向的源文件实体。

    软链接图解

    这里写图片描述

    查看软链接的value:

    [root@oldboy test]# readlink link
    
    file
    
    #可以看到link这个软链接文件是指向file这个文件的
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    创建软链接

    #加个 -s 参数即可
    
    [root@oldboy test]# ln -s file link
    
    • 1
    • 2
    • 3
    • 4

    5.3.1 软链接知识小结

    1、软链接类似Windows的快捷方式(可以通过readlink查看其指向)

    2、软链接类似一个文本文件,里面存放的是源文件的路径,指向源文件实体。

    3、删除源文件,软连接文件依然存在,但是无法访问指向的源文件路径内容了。

    4、软链接失效的时候一般是白色红底闪烁提示。

    5、执行命令“ln -s 源文件 软链接文件”,即可完成创建软链接(目标不能存在)。

    6、软链接和源文件是不同类型的文件,也是不同的文件。inode号也不相同。

    7、软链接文件的文件类型为(l),可以用rm命令删除。

    5.4 有关文件链接的小结

    1、删除软链接文件对源文件及硬链接文件无任何影响。

    2、删除硬链接文件对源文件及软连接文件无任何影响。

    3、删除源文件,对应链接文件没有影响,但是会导致软连接文件失效,白字红底闪烁。

    4、同时删除源文件和硬链接文件,整个文件会真正的被删除。

    5、很多硬件设备中的快照功能,就是利用了硬链接的原理。

    6、源文件和硬链接文件具有相同的索引节点,可以认为是同一文件或一个文件的多个入口。

    7、源文件和硬链接文件索引节点号不同,是不同的文件,软链接相当于源文件的快捷方式,含有源文件的位置指向。

    5.5 有关目录链接的小结

    1、对于目录,不可以创建硬链接,但是可以创建软链接

    其系统默认在目录下创建“.”硬链接,但是用户不能用ln命令给目录创建硬链接

    2、对于目录的软链接是生产场景中常用的技巧,即把一个很深层次的目录给做一个软链接,就相当于整一个快捷方式。

    3、目录的硬链接不能跨文件系统(从硬链接原理理解)

    4、每个目录下面都有一个硬链接“.”号,和对应上级目录的硬链接“..”。

    5、在父目录里创建一个子目录,父目录的链接数增加1(每个子目录里都有..来指向父目录)。但是在父目录里创建文件,父目录的链接数不会增加。

    为什么说“.”代表当前目录,因为“.”和oldboy的inode号相同

    [root@oldboy test]# ll -a oldboy/. oldboy/ -ldi
    
    140162 drwxr-xr-x. 2 root root 4096 Dec 16 00:14 oldboy/
    
    140162 drwxr-xr-x. 2 root root 4096 Dec 16 00:14 oldboy/.
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    为什么说“..”代表上一层目录,因为“../test”和oldboy/..的inode号相同

    [root@oldboy test]# ll -a oldboy/.. ../test/ -ldi
    
    140161 drwxr-xr-x. 3 root root 4096 Dec 16 00:14 oldboy/..
    
    140161 drwxr-xr-x. 3 root root 4096 Dec 16 00:14 ../test/
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    #为什么上面硬链接数为3?

    [root@oldboy test]# ll -a oldboy/.. ../test/ ../test/. -ldi
    
    140161 drwxr-xr-x. 3 root root 4096 Dec 16 00:14 oldboy/..
    
    140161 drwxr-xr-x. 3 root root 4096 Dec 16 00:14 ../test/
    
    140161 drwxr-xr-x. 3 root root 4096 Dec 16 00:14 ../test/.
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    5.6 描述linux下软链接和硬链接的区别

    1、默认不带参数的情况下,ln命令创建的是硬链接,带 -s 
    参数的ln命令创建的是软链接。

    2、硬链接文件与源文件的inode节点号相同,而软连接文件的inode节点号与源文件不同。

    3、ln命令不能目录创建硬链接,但是可以创建软链接,对目录的软链接会经常被用到。

    4、删除软链接文件,对源文件及硬链接文件无任何影响。

    5、删除文件的硬链接文件,对源文件及软链接文件无任何影响

    6、删除链接文件的源文件对硬链接文件无影响,会导致其软链接失效(红底白字闪烁状)

    7、同时删除源文件及其硬链接文件,整个文件才会被真正的删除

    8、很多硬件设备中的快照功能,使用的就类似硬链接的原理

    9、软链接可以跨文件系统,硬链接不可以跨文件系统

    6 Linux下文件删除的原理

    linux的文件名是存在父目录的bolck里面,并指向这个文件的inode节点,这个文件的inode节点再标记指向存放这个文件的bolck的数据块。我们删除一个文件,实际上并不清除inode 节点和block 
    的数据。只是在这个文件的父目录里面的bolck中,删除这个文件的名字,从而使这个文件名消失,并且无法指向这个文件的inode节点,当没有文件名指向这个inode 节点的时候,会同时释放inode节点和存放这个文件的数据块,并更新inode MAP和block MAP今后让这些位置可以用于放置其他文件数据。

    删除原理图:

    这里写图片描述

    说明:以上图形i_link=2和i_count=1

    i_link(硬链接数量)为0,文件就被删除。。

    i_count(进程引用计数)为0,文件就被删除。

    文件删除的条件i_link=0并且i_count=0

    企业案例1:Web服务器磁盘满故障深入解析

    参考博客:http://oldboy.blog.51cto.com/2561410/612351

    企业案例2:磁盘满的另外的故障(inode满)

    小文件:sendmail产生的日志文件,很小

    7 Linux文件属性之用户和组

    Linux/Unix是一个多用户、多任务的操作系统。

    7.1 Linux系统中用户角色划分

    在linux系统中用户是分角色的,在Linux系统中,由于角色不同,权限和所完成的任务也不同; 
    值得注意的是,对于linux系统来说,用户的角色是通过UD和GID识别的;特别是UID,在linux系统运维工作中,一个UID是唯一标识一个系统用户的帐号(相当于我们的身份证)。用户系统帐号的名称(如oldboy)其实给人(管理员)看的,linux系统能够识别的仅仅是UID和GID这样的数字。用户的UID就相当于我们的身份证一样,用户名就相当于我们的名字。

    UID(User Identify) 中文:用户ID,相当于我们的身份证,在系统里是唯一的

    GID(Group Identity)中文:组ID,相当于我们的家庭或我们学校的ID。

    用户分为三类:

    (1)超级用户:

    默认是root用户,其UID和GID均为0.root用户在每台unix/Linux操作系统重都是唯一且真是存在的,通过它可以登录系统,可以操作系统中任何文件和命令,拥有最高的管理权限。

    在生产环境中,一般会禁止root账号通过ssh远程连接服务器(保护好皇帝),当然,也会更改默认的ssh端口(保护好皇宫),以加强系统安全。

    企业工作中:没有特殊需求,应尽量在普通用户下操作任务,而不是root。

    在Linux系统中,uid为0的用户就是超级用户,但是通常不这么做,二十sudo管理提权,可以细到每个命令权限分配。

    Root比喻皇帝。Root家目录为皇宫

    (2)普通用户

    这类用户一般是由具备系统管理员rpot的权限的运维或系统管理人员添加的。例如:oldboy 
    这类用户可以登录系统,但仅具备操作自己家目录中的文件及目录的权限,除此之外,还可以进入、或浏览相关目录(/etc,/var/log),但是无法创建、修改和删除;

    普通用户: 比喻皇帝的臣民,干坏事时,国家有法律管束你。为普通用户授权(sudo),封官。布衣也可以提权。

    su - root,角色切换,农民起义,推翻皇帝,自己当皇帝。

    sudo ls 授权、风管,尚方宝剑。可以为皇帝办事,有一定权限,但还是自己。

    (3)虚拟用户

    与真实普通用户区分开来,这类用户最大的特点是安装系统后默认就会存在,且默认情况大多数不能登录系统,但是,他们是系统正常运行不可缺少的,它们的存在主要是方便系统管理,满足相应的系统进程对文件属主的要求。例如:系统默认的bin、adm、nobody、mail用户等。由于服务器业务角色的不同,有部分用不到的系统服务被禁止开机执行,因此,在做系统安全优化时,被禁止开机启动了的服务对应的虚拟用户也是可以处理掉的(删除或注释)

    虚拟用户角色傀儡:

    Linux安全优化

    1、安装系统后可以删除用不到的虚拟用户,但最好不删除而是注释掉,万一出问题可以恢复过来。

    2、我们自己部署服务的时候,也会创建虚拟用户,满足服务的要求!例如:apache、nginx、mysql、nfs、rsync、nagios、zabbix、redis。

    7.2 Linux系统中不同用户角色对应的UID说明

    超级用户: 0

    虚拟用户: 1-499

    普通用户: 500-65535

    7.3 用户和组的配置文件

    Linux系统下的账户文件主要有/etc/passwd、/etc/group、/etc/shadow、/etc/gshadow四个文件。

    /etc/passwd #->用户的配置文件

    /etc/shadow #->用户影子口令文件

    密码文件/etc/passwd:

    字段解释:

    这里写图片描述

    shell解释器:

    [root@oldboy ~]# cat /etc/shells
    /bin/sh
    /bin/bash
    /sbin/nologin
    /bin/dash
    /bin/tcsh
    /bin/csh
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    影子口令文件/etc/shadow

    由于passwd文件必须要被所有的用户读,所以会带来安全隐患。而shadow文件就是为了解决这个安全隐患而增加的。看一下这个文件的权限:

    [root@oldboy ~]# ls -l /etc/shadow
    
    ----------. 1 root root 721 Dec 16 01:36 /etc/shadow
    
    这样是很安全的。
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    shadow字段说明:

    这里写图片描述

    和组相关的配置文件:

    /etc/group
    
    /etc/gshadow
    
    • 1
    • 2
    • 3
    • 4

    用id来查看用户的uid和gid等信息

    [root@oldboy ~]# id root
    
    uid=0(root) gid=0(root) groups=0(root)
    
    [root@oldboy ~]# useradd rsq
    
    [root@oldboy ~]# id rsq
    
    uid=500(rsq) gid=500(rsq) groups=500(rsq)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    8 Linux时间戳

    ls -lhi 的7、8、9是时间(默认是修改时间)

    modify修改 -mtime(修改文件内容的时候)

    change改变时间 -ctime(属性改变)

    access访问时间 -atime(访问文件内容的时候)

    #一般若改变文件内容的时候modify和change都会发生改变,一般改变文件内容,文件的大小就会发生改变,即属性发生改变。

    规范时间的参数 –time-style=long-iso

    [root@oldboy test]# ll
    
    total 4
    
    drwxr-xr-x. 2 root root 4096 Dec 16 00:14 oldboy
    
    [root@oldboy test]# ll --time-style=long-iso
    
    total 4
    
    drwxr-xr-x. 2 root root 4096 2017-12-16 00:14 oldboy
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    #显示的更全

    [root@oldboy test]# ll --time-style=full
    
    total 4
    
    drwxr-xr-x. 2 root root 4096 2017-12-16 00:14:58.405967561 -0500 oldboy
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    显示文件的各种时间戳

    [root@oldboy oldboy]# stat oldboyfile
    
    File: `oldboyfile'
    
    Size: 0 Blocks: 0 IO Block: 4096 regular empty file
    
    Device: 803h/2051d Inode: 140163 Links: 2
    
    Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
    
    Access: 2017-12-15 23:01:22.281943883 -0500
    
    Modify: 2017-12-15 23:01:22.281943883 -0500
    
    Change: 2017-12-15 23:01:35.873966214 -0500
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    简单的测试各种时间戳改变

    [root@oldboy oldboy]# cat w
    
    123
    
    [root@oldboy oldboy]# stat w
    
    File: `w'
    
    Size: 4 Blocks: 8 IO Block: 4096 regular file
    
    Device: 803h/2051d Inode: 140165 Links: 1
    
    Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
    
    Access: 2017-12-16 07:54:39.700956755 -0500
    
    Modify: 2017-12-16 00:14:40.480969366 -0500
    
    Change: 2017-12-16 06:51:03.002957994 -0500
    
    [root@oldboy oldboy]# echo 321 > w
    
    [root@oldboy oldboy]# stat w
    
    File: `w'
    
    Size: 4 Blocks: 8 IO Block: 4096 regular file
    
    Device: 803h/2051d Inode: 140165 Links: 1
    
    Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
    
    Access: 2017-12-16 07:54:39.700956755 -0500
    
    Modify: 2017-12-16 07:55:09.555960261 -0500
    
    Change: 2017-12-16 07:55:09.555960261 -0500  
    [root@oldboy oldboy]# cat w
    
    321
    
    [root@oldboy oldboy]# stat w
    
    File: `w'
    
    Size: 4 Blocks: 8 IO Block: 4096 regular file
    
    Device: 803h/2051d Inode: 140165 Links: 1
    
    Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 0/ root)
    
    Access: 2017-12-16 07:55:45.973957462 -0500
    
    Modify: 2017-12-16 07:55:09.555960261 -0500
    
    Change: 2017-12-16 07:55:09.555960261 -0500
    
    [root@oldboy oldboy]# chown root.test w
    
    [root@oldboy oldboy]# stat w
    
    File: `w'
    
    Size: 4 Blocks: 8 IO Block: 4096 regular file
    
    Device: 803h/2051d Inode: 140165 Links: 1
    
    Access: (0644/-rw-r--r--) Uid: ( 0/ root) Gid: ( 501/ test)
    
    Access: 2017-12-16 07:55:45.973957462 -0500
    
    Modify: 2017-12-16 07:55:09.555960261 -0500
    
    Change: 2017-12-16 08:00:41.921954381 -0500
    
    • 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

    第十列 文件名 不在文件inode里,而是在上级目录的block中



    转载至https://blog.csdn.net/mr_rsq/article/details/78880922


    展开全文
  • 如果需要查看Hadoop HDFS 中的一个文件对应block信息,比如block数、block大小、block所在位置等,可以使用hdfs fsck命令。1. HDFS示例文件[root@node1 data]# hdfs dfs -ls /user/root/input Found 7 items -rw-r--...

    本文地址:http://blog.csdn.net/chengyuqiang/article/details/78163091

    如果需要查看Hadoop HDFS 中的一个文件对应block信息,比如block数、block大小、block所在位置等,可以使用hdfs fsck命令。

    1. HDFS示例文件

    hdfs dfs -ls /user/root/input

    [root@node1 data]# hdfs dfs -ls /user/root/input
    Found 7 items
    -rw-r--r--   3 root supergroup     281498 2017-09-20 10:11 /user/root/input/Hamlet.txt
    -rw-r--r--   3 root supergroup    9789248 2017-09-22 10:26 /user/root/input/age.txt
    -rw-r--r--   3 root supergroup         71 2017-08-27 09:18 /user/root/input/books.txt
    -rw-r--r--   3 root supergroup  264075431 2017-10-05 09:37 /user/root/input/cite75_99.txt
    drwxr-xr-x   - root supergroup          0 2017-08-13 09:33 /user/root/input/emp.bak
    drwxr-xr-x   - root supergroup          0 2017-09-24 04:08 /user/root/input/ml-1m
    -rw-r--r--   3 root supergroup  871353053 2017-10-05 09:40 /user/root/input/ncdc.txt
    [root@node1 data]#

    2. hdfs fsck用法

    [root@node1 data]# hdfs fsck 
    Usage: hdfs fsck <path> [-list-corruptfileblocks | [-move | -delete | -openforwrite] [-files [-blocks [-locations | -racks]]]] [-includeSnapshots] [-storagepolicies] [-blockId <blk_Id>]
        <path>  start checking from this path
        -move   move corrupted files to /lost+found
        -delete delete corrupted files
        -files  print out files being checked
        -openforwrite   print out files opened for write
        -includeSnapshots   include snapshot data if the given path indicates a snapshottable directory or there are snapshottable directories under it
        -list-corruptfileblocks print out list of missing blocks and files they belong to
        -blocks print out block report
        -locations  print out locations for every block
        -racks  print out network topology for data-node locations
        -storagepolicies    print out storage policy summary for the blocks
        -blockId    print out which file this blockId belongs to, locations (nodes, racks) of this block, and other diagnostics info (under replicated, corrupted or not, etc)
    
    Please Note:
        1. By default fsck ignores files opened for write, use -openforwrite to report such files. They are usually  tagged CORRUPT or HEALTHY depending on their block allocation status
        2. Option -includeSnapshots should not be used for comparing stats, should be used only for HEALTH check, as this may contain duplicates if the same file present in both original fs tree and inside snapshots.
    
    Generic options supported are
    -conf <configuration file>     specify an application configuration file
    -D <property=value>            use value for given property
    -fs <local|namenode:port>      specify a namenode
    -jt <local|resourcemanager:port>    specify a ResourceManager
    -files <comma separated list of files>    specify comma separated files to be copied to the map reduce cluster
    -libjars <comma separated list of jars>    specify comma separated jar files to include in the classpath.
    -archives <comma separated list of archives>    specify comma separated archives to be unarchived on the compute machines.
    
    The general command line syntax is
    bin/hadoop command [genericOptions] [commandOptions]
    
    Generic options supported are
    -conf <configuration file>     specify an application configuration file
    -D <property=value>            use value for given property
    -fs <local|namenode:port>      specify a namenode
    -jt <local|resourcemanager:port>    specify a ResourceManager
    -files <comma separated list of files>    specify comma separated files to be copied to the map reduce cluster
    -libjars <comma separated list of jars>    specify comma separated jar files to include in the classpath.
    -archives <comma separated list of archives>    specify comma separated archives to be unarchived on the compute machines.
    
    The general command line syntax is
    bin/hadoop command [genericOptions] [commandOptions]
    
    [root@node1 data]# 
    

    3. 查看block基本信息

    hdfs fsck input/cite75_99.txt

    [root@node1 data]# hdfs fsck input/cite75_99.txt
    Connecting to namenode via http://node1:50070/fsck?ugi=root&path=%2Fuser%2Froot%2Finput%2Fcite75_99.txt
    FSCK started by root (auth:SIMPLE) from /192.168.80.131 for path /user/root/input/cite75_99.txt at Thu Oct 05 09:41:58 EDT 2017
    .Status: HEALTHY
     Total size:    264075431 B
     Total dirs:    0
     Total files:   1
     Total symlinks:        0
     Total blocks (validated):  2 (avg. block size 132037715 B)
     Minimally replicated blocks:   2 (100.0 %)
     Over-replicated blocks:    0 (0.0 %)
     Under-replicated blocks:   0 (0.0 %)
     Mis-replicated blocks:     0 (0.0 %)
     Default replication factor:    3
     Average block replication: 3.0
     Corrupt blocks:        0
     Missing replicas:      0 (0.0 %)
     Number of data-nodes:      3
     Number of racks:       1
    FSCK ended at Thu Oct 05 09:41:58 EDT 2017 in 3 milliseconds
    
    
    The filesystem under path '/user/root/input/cite75_99.txt' is HEALTHY
    [root@node1 data]# hdfs fsck input/ncdc.txt
    Connecting to namenode via http://node1:50070/fsck?ugi=root&path=%2Fuser%2Froot%2Finput%2Fncdc.txt
    FSCK started by root (auth:SIMPLE) from /192.168.80.131 for path /user/root/input/ncdc.txt at Thu Oct 05 09:42:22 EDT 2017
    .Status: HEALTHY
     Total size:    871353053 B
     Total dirs:    0
     Total files:   1
     Total symlinks:        0
     Total blocks (validated):  7 (avg. block size 124479007 B)
     Minimally replicated blocks:   7 (100.0 %)
     Over-replicated blocks:    0 (0.0 %)
     Under-replicated blocks:   0 (0.0 %)
     Mis-replicated blocks:     0 (0.0 %)
     Default replication factor:    3
     Average block replication: 3.0
     Corrupt blocks:        0
     Missing replicas:      0 (0.0 %)
     Number of data-nodes:      3
     Number of racks:       1
    FSCK ended at Thu Oct 05 09:42:22 EDT 2017 in 2 milliseconds
    
    
    The filesystem under path '/user/root/input/ncdc.txt' is HEALTHY
    [root@node1 data]# 
    

    4. -files -blocks -locations选项

    hdfs fsck input/ncdc.txt -files -blocks
    hdfs fsck input/ncdc.txt -files -blocks -locations

    [root@node1 data]# hdfs fsck input/ncdc.txt -files -blocks
    Connecting to namenode via http://node1:50070/fsck?ugi=root&files=1&blocks=1&path=%2Fuser%2Froot%2Finput%2Fncdc.txt
    FSCK started by root (auth:SIMPLE) from /192.168.80.131 for path /user/root/input/ncdc.txt at Thu Oct 05 09:47:14 EDT 2017
    /user/root/input/ncdc.txt 871353053 bytes, 7 block(s):  OK
    0. BP-766589174-192.168.80.131-1500731607717:blk_1073742821_2026 len=134217728 repl=3
    1. BP-766589174-192.168.80.131-1500731607717:blk_1073742822_2027 len=134217728 repl=3
    2. BP-766589174-192.168.80.131-1500731607717:blk_1073742823_2028 len=134217728 repl=3
    3. BP-766589174-192.168.80.131-1500731607717:blk_1073742824_2029 len=134217728 repl=3
    4. BP-766589174-192.168.80.131-1500731607717:blk_1073742825_2030 len=134217728 repl=3
    5. BP-766589174-192.168.80.131-1500731607717:blk_1073742826_2031 len=134217728 repl=3
    6. BP-766589174-192.168.80.131-1500731607717:blk_1073742827_2032 len=66046685 repl=3
    
    Status: HEALTHY
     Total size:    871353053 B
     Total dirs:    0
     Total files:   1
     Total symlinks:        0
     Total blocks (validated):  7 (avg. block size 124479007 B)
     Minimally replicated blocks:   7 (100.0 %)
     Over-replicated blocks:    0 (0.0 %)
     Under-replicated blocks:   0 (0.0 %)
     Mis-replicated blocks:     0 (0.0 %)
     Default replication factor:    3
     Average block replication: 3.0
     Corrupt blocks:        0
     Missing replicas:      0 (0.0 %)
     Number of data-nodes:      3
     Number of racks:       1
    FSCK ended at Thu Oct 05 09:47:14 EDT 2017 in 2 milliseconds
    
    
    The filesystem under path '/user/root/input/ncdc.txt' is HEALTHY
    [root@node1 data]# hdfs fsck input/ncdc.txt -files -blocks -locations
    Connecting to namenode via http://node1:50070/fsck?ugi=root&files=1&blocks=1&locations=1&path=%2Fuser%2Froot%2Finput%2Fncdc.txt
    FSCK started by root (auth:SIMPLE) from /192.168.80.131 for path /user/root/input/ncdc.txt at Thu Oct 05 09:47:45 EDT 2017
    /user/root/input/ncdc.txt 871353053 bytes, 7 block(s):  OK
    0. BP-766589174-192.168.80.131-1500731607717:blk_1073742821_2026 len=134217728 repl=3 [DatanodeInfoWithStorage[192.168.80.131:50010,DS-602e79bf-d01e-4b6b-8712-f6293e394ab1,DISK], DatanodeInfoWithStorage[192.168.80.133:50010,DS-0056ec91-47b7-4c48-8f6e-89ca33be49c6,DISK], DatanodeInfoWithStorage[192.168.80.132:50010,DS-d3917eb8-31b4-49d6-b5eb-1316f7c0f310,DISK]]
    1. BP-766589174-192.168.80.131-1500731607717:blk_1073742822_2027 len=134217728 repl=3 [DatanodeInfoWithStorage[192.168.80.131:50010,DS-602e79bf-d01e-4b6b-8712-f6293e394ab1,DISK], DatanodeInfoWithStorage[192.168.80.132:50010,DS-d3917eb8-31b4-49d6-b5eb-1316f7c0f310,DISK], DatanodeInfoWithStorage[192.168.80.133:50010,DS-0056ec91-47b7-4c48-8f6e-89ca33be49c6,DISK]]
    2. BP-766589174-192.168.80.131-1500731607717:blk_1073742823_2028 len=134217728 repl=3 [DatanodeInfoWithStorage[192.168.80.132:50010,DS-d3917eb8-31b4-49d6-b5eb-1316f7c0f310,DISK], DatanodeInfoWithStorage[192.168.80.133:50010,DS-0056ec91-47b7-4c48-8f6e-89ca33be49c6,DISK], DatanodeInfoWithStorage[192.168.80.131:50010,DS-602e79bf-d01e-4b6b-8712-f6293e394ab1,DISK]]
    3. BP-766589174-192.168.80.131-1500731607717:blk_1073742824_2029 len=134217728 repl=3 [DatanodeInfoWithStorage[192.168.80.131:50010,DS-602e79bf-d01e-4b6b-8712-f6293e394ab1,DISK], DatanodeInfoWithStorage[192.168.80.132:50010,DS-d3917eb8-31b4-49d6-b5eb-1316f7c0f310,DISK], DatanodeInfoWithStorage[192.168.80.133:50010,DS-0056ec91-47b7-4c48-8f6e-89ca33be49c6,DISK]]
    4. BP-766589174-192.168.80.131-1500731607717:blk_1073742825_2030 len=134217728 repl=3 [DatanodeInfoWithStorage[192.168.80.131:50010,DS-602e79bf-d01e-4b6b-8712-f6293e394ab1,DISK], DatanodeInfoWithStorage[192.168.80.132:50010,DS-d3917eb8-31b4-49d6-b5eb-1316f7c0f310,DISK], DatanodeInfoWithStorage[192.168.80.133:50010,DS-0056ec91-47b7-4c48-8f6e-89ca33be49c6,DISK]]
    5. BP-766589174-192.168.80.131-1500731607717:blk_1073742826_2031 len=134217728 repl=3 [DatanodeInfoWithStorage[192.168.80.131:50010,DS-602e79bf-d01e-4b6b-8712-f6293e394ab1,DISK], DatanodeInfoWithStorage[192.168.80.132:50010,DS-d3917eb8-31b4-49d6-b5eb-1316f7c0f310,DISK], DatanodeInfoWithStorage[192.168.80.133:50010,DS-0056ec91-47b7-4c48-8f6e-89ca33be49c6,DISK]]
    6. BP-766589174-192.168.80.131-1500731607717:blk_1073742827_2032 len=66046685 repl=3 [DatanodeInfoWithStorage[192.168.80.131:50010,DS-602e79bf-d01e-4b6b-8712-f6293e394ab1,DISK], DatanodeInfoWithStorage[192.168.80.133:50010,DS-0056ec91-47b7-4c48-8f6e-89ca33be49c6,DISK], DatanodeInfoWithStorage[192.168.80.132:50010,DS-d3917eb8-31b4-49d6-b5eb-1316f7c0f310,DISK]]
    
    Status: HEALTHY
     Total size:    871353053 B
     Total dirs:    0
     Total files:   1
     Total symlinks:        0
     Total blocks (validated):  7 (avg. block size 124479007 B)
     Minimally replicated blocks:   7 (100.0 %)
     Over-replicated blocks:    0 (0.0 %)
     Under-replicated blocks:   0 (0.0 %)
     Mis-replicated blocks:     0 (0.0 %)
     Default replication factor:    3
     Average block replication: 3.0
     Corrupt blocks:        0
     Missing replicas:      0 (0.0 %)
     Number of data-nodes:      3
     Number of racks:       1
    FSCK ended at Thu Oct 05 09:47:45 EDT 2017 in 2 milliseconds
    
    
    The filesystem under path '/user/root/input/ncdc.txt' is HEALTHY
    [root@node1 data]#
    展开全文
  • 查看block的大小tune2fs-l /dev/sda1 | grep "Block size" #使用tune方法这里Linux的“block size”指的...但linux的文件系统的block确不一样。例如ext3,4系统,block size是4096。使用df命令可以查看例...

    查看block的大小

    tune2fs-l /dev/sda1 | grep "Block size"     #使用tune方法

    这里Linux的“block size”指的是1024 bytes,Linux用1024-byte blocks 作为buffer cache的基本单位。但linux的文件系统的block确不一样。例如ext3,4系统,block size是4096。使用df命令可以查看

    例如:

    stat -f .       #查看本目录的信息

    File:"."

        ID: a333db0bd4c06027 Namelen: 255     Type: ext2/ext3

    Blocksize: 4096       Fundamental block size:4096

    Blocks:Total: 2409635    Free: 2200914    Available: 2078508

    Inodes: Total: 613200     Free: 589791

    可以看出,blocksize是4096字节。

    结论:ext3,ext4的文件系统,默认的block size是4096字节,一般不用修改。

     

    修改block的大小:

    创建文件系统时,可以指定块的大小。如果将来在你的文件系统中是一些比较大的文件的话,使用较大的块大小将得到较好的性能。将ext2文件系统的块大小调整 为4096byte而不是缺省的1024byte,可以减少文件碎片,加快fsck扫描的速度和文件删除以及读操作的速度。另外,在ext2的文件系统 中,为根目录保留了5%的空间,对一个大的文件系统,除非用作日志文件,5%的比例有些过多。可以使用命令

    mke2fs-b 4096 -m 1 /dev/hda6       #将它改为1%并以块大小4096byte创建文件系统。

        使用多大的block,要根据实际工作的需要来确认。如果很多小于4K的小文件,可以考虑修改block的大小。不过由于现在硬盘的容量已经非常的大,而且价格也不是很贵,工作中,就算是邮件服务器的话,小于4K和大于4K的文件的比例也不是很悬殊,所以一般不用去修改。

    展开全文
  • 我们可以从java.io.InputStream类中看到,抽象出一个read方法,用来读取已经打开的InputStream实例中的字节,每次调用read方法,会读取一个字节数据,该方法抽象定义,如下所示: public abstract int read() ...

      我们可以从java.io.InputStream类中看到,抽象出一个read方法,用来读取已经打开的InputStream实例中的字节,每次调用read方法,会读取一个字节数据,该方法抽象定义,如下所示:
    public abstract int read() throws IOException;
      Hadoop的DFSClient.DFSInputStream类实现了该抽象逻辑,如果我们清楚了如何从HDFS中读取一个文件的一个block的一个字节的原理,更加抽象的顶层只需要迭代即可获取到该文件的全部数据。
      从HDFS读文件过程分析:获取文件对应的Block列表(原文链接:http://shiyanjun.cn/archives/925.html)中,我们已经获取到一个文件对应的Block列表信息,打开一个文件,接下来就要读取实际的物理块数据,我们从下面的几个方面来详细说明读取数据的过程。

    Client从Datanode读取文件的一个字节

      下面,我们通过分析DFSClient.DFSInputStream中实现的代码,读取HDFS上文件的内容。首先从下面的方法开始:
      

    @Override
    public synchronized int read() throws IOException {
      int ret = read( oneByteBuf, 0, 1 );
      return ( ret <= 0 ) ? -1 : (oneByteBuf[0] & 0xff);
    }

      上面调用read(oneByteBuf, 0, 1)读取一个字节到单字节缓冲区oneByteBuf中,具体实现见如下方法:
      

    @Override
    public synchronized int read(byte buf[], int off, int len) throws IOException {
      checkOpen(); // 检查Client是否正在运行
      if (closed) {
        throw new IOException("Stream closed");
      }
      failures = 0;
    
      if (pos < getFileLength()) { // getFileLength()获取文件所包含的总字节数,pos表示读取当前文件的第(pos+1)个字节
        int retries = 2;
        while (retries > 0) {
          try {
            if (pos > blockEnd) { // blockEnd表示文件的长度(字节数)
              currentNode = blockSeekTo(pos); // 找到第pos个字节数据所在的Datanode(实际根据该字节数据所在的block元数据来定位)
            }
            int realLen = (int) Math.min((long) len, (blockEnd - pos + 1L));
            int result = readBuffer(buf, off, realLen); // 读取一个字节到缓冲区中
    
            if (result >= 0) {
              pos += result; // 每成功读取result个字节,pos增加result
            } else {
              // got a EOS from reader though we expect more data on it.
              throw new IOException("Unexpected EOS from the reader");
            }
            if (stats != null && result != -1) {
              stats.incrementBytesRead(result);
            }
            return result;
          } catch (ChecksumException ce) {
            throw ce;           
          } catch (IOException e) {
            if (retries == 1) {
              LOG.warn("DFS Read: " + StringUtils.stringifyException(e));
            }
            blockEnd = -1;
            if (currentNode != null) { addToDeadNodes(currentNode); }
            if (--retries == 0) {
              throw e;
            }
          }
        }
      }
      return -1;
    }

    读取文件数据的一个字节,具体过程如下:

      检查流对象是否处于打开状态(前面已经获取到文件对应的block列表的元数据,并打开一个InputStream对象)
    从文件的第一个block开始读取,首先需要找到第一个block对应的数据块所在的Datanode,可以从缓存的block列表中查询到(如果查找不到,则会与Namenode进行一次RPC通信请求获取到)
      打开一个到该读取的block所在Datanode节点的流,准备读取block数据
      建立了到Datanode的连接后,读取一个字节数据到字节缓冲区中,返回读取的字节数(1个字节)
      在读取的过程中,以字节为单位,通过判断某个偏移位置的字节属于哪个block(根据block元数据所限定的字节偏移范围),在根据这个block去定位某一个Datanode节点,这样就可连续地读取一个文件的全部数据(组成文件的、连续的多个block数据块)。

    查找待读取的一个字节所在的Datanode节点

      上面public synchronized int read(byte buf[], int off, int len) throws IOException方法,调用了blockSeekTo方法来获取,文件某个字节索引位置的数据所在的Datanode节点。其实,很容易就能想到,想要获取到数据所在的Datanode节点,一定是从block元数据中计算得到,然后根据Client缓存的block映射列表,找到block对应的Datanode列表,我们看一下blockSeekTo方法的代码实现:
      

    private synchronized DatanodeInfo blockSeekTo(long target) throws IOException {
      ... ...
    
      DatanodeInfo chosenNode = null;
      int refetchToken = 1; // only need to get a new access token once
      while (true) {
        LocatedBlock targetBlock = getBlockAt(target, true); // 获取字节偏移位置为target的字节数据所在的block元数据对象
        assert (target==this.pos) : "Wrong postion " + pos + " expect " + target;
        long offsetIntoBlock = target - targetBlock.getStartOffset();
    
        DNAddrPair retval = chooseDataNode(targetBlock); // 选择一个Datanode去读取数据
        chosenNode = retval.info;
        InetSocketAddress targetAddr = retval.addr;
    
        // 先尝试从本地读取数据,如果数据不在本地,则正常去读取远程的Datanode节点
        Block blk = targetBlock.getBlock();
        Token<BlockTokenIdentifier> accessToken = targetBlock.getBlockToken();
        if (shouldTryShortCircuitRead(targetAddr)) {
          try {
            blockReader = getLocalBlockReader(conf, src, blk, accessToken,
                chosenNode, DFSClient.this.socketTimeout, offsetIntoBlock); // 创建一个用来读取本地数据的BlockReader对象
            return chosenNode;
          } catch (AccessControlException ex) {
            LOG.warn("Short circuit access failed ", ex);
            //Disable short circuit reads
            shortCircuitLocalReads = false;
          } catch (IOException ex) {
            if (refetchToken > 0 && tokenRefetchNeeded(ex, targetAddr)) {
              /* Get a new access token and retry. */
              refetchToken--;
              fetchBlockAt(target);
              continue;
            } else {
              LOG.info("Failed to read " + targetBlock.getBlock()
                  + " on local machine" + StringUtils.stringifyException(ex));
              LOG.info("Try reading via the datanode on " + targetAddr);
            }
          }
        }
    
        // 本地读取失败,按照更一般的方式去读取远程的Datanode节点来获取数据
        try {
          s = socketFactory.createSocket();
          LOG.debug("Connecting to " + targetAddr);
          NetUtils.connect(s, targetAddr, getRandomLocalInterfaceAddr(), socketTimeout);
          s.setSoTimeout(socketTimeout);
          blockReader = RemoteBlockReader.newBlockReader(s, src, blk.getBlockId(),
              accessToken,
              blk.getGenerationStamp(),
              offsetIntoBlock, blk.getNumBytes() - offsetIntoBlock,
              buffersize, verifyChecksum, clientName); // 创建一个远程的BlockReader对象
          return chosenNode;
        } catch (IOException ex) {
          if (refetchToken > 0 && tokenRefetchNeeded(ex, targetAddr)) {
            refetchToken--;
            fetchBlockAt(target);
          } else {
            LOG.warn("Failed to connect to " + targetAddr
                + ", add to deadNodes and continue" + ex);
            if (LOG.isDebugEnabled()) {
              LOG.debug("Connection failure", ex);
            }
            // Put chosen node into dead list, continue
            addToDeadNodes(chosenNode); // 读取失败,会将选择的Datanode加入到Client的dead node列表,为下次读取选择合适的Datanode读取文件数据提供参考元数据信息
          }
          if (s != null) {
            try {
              s.close();
            } catch (IOException iex) { }                       
          }
          s = null;
        }
      }
    }

    上面代码中,主要包括如下几个要点:

    • 选择合适的Datanode节点,提高读取效率

        在读取文件的时候,首先会从Namenode获取文件对应的block列表元数据,返回的block列表是按照Datanode的网络拓扑结构进行排序过的(本地节点优先,其次是同一机架节点),而且,Client还维护了一个dead node列表,只要此时bock对应的Datanode列表中节点不出现在dead node列表中就会被返回,用来作为读取数据的Datanode节点。

    • 如果Client为集群Datanode节点,尝试从本地读取block

        通过调用chooseDataNode方法返回一个Datanode结点,通过判断,如果该节点地址是本地地址,并且该节点上对应的block元数据信息的状态不是正在创建的状态,则满足从本地读取数据块的条件,然后会创建一个LocalBlockReader对象,直接从本地读取。在创建LocalBlockReader对象的过程中,会先从缓存中查找一个本地Datanode相关的LocalDatanodeInfo对象,该对象定义了与从本地Datanode读取数据的重要信息,以及缓存了待读取block对应的本地路径信息,可以从LocalDatanodeInfo类定义的属性来说明:
        

    private ClientDatanodeProtocol proxy = null;
    private final Map<Block, BlockLocalPathInfo> cache;

      如果缓存中存在待读取的block的相关信息,可以直接进行读取;否则,会创建一个proxy对象,以及计算待读取block的路径信息BlockLocalPathInfo,最后再加入到缓存,为后续可能的读取加速。我们看一下如果没有从缓存中找到LocalDatanodeInfo信息(尤其是BlockLocalPathInfo),则会执行如下逻辑:
      

    // make RPC to local datanode to find local pathnames of blocks
    pathinfo = proxy.getBlockLocalPathInfo(blk, token);

      上面proxy为ClientDatanodeProtocol类型,Client与Datanode进行RPC通信的协议,RPC调用getBlockLocalPathInfo获取block对应的本地路径信息,可以在Datanode类中查看具体实现,如下所示:
      

    BlockLocalPathInfo info = data.getBlockLocalPathInfo(block);
    

    Datanode调用FSDataset(实现接口FSDatasetInterface)的getBlockLocalPathInfo,如下所示:

    @Override //FSDatasetInterface
    public BlockLocalPathInfo getBlockLocalPathInfo(Block block)
        throws IOException {
      File datafile = getBlockFile(block); // 获取本地block在本地Datanode文件系统中的文件路径
      File metafile = getMetaFile(datafile, block);  // 获取本地block在本地Datanode文件系统中的元数据的文件路径
      BlockLocalPathInfo info = new BlockLocalPathInfo(block, datafile.getAbsolutePath(), metafile.getAbsolutePath());
      return info;
    }

    接着可以直接去读取该block文件(如果需要检查校验和文件,会读取block的元数据文件metafile):

    ... // BlockReaderLocal类的newBlockReader静态方法
    // get a local file system
    File blkfile = new File(pathinfo.getBlockPath());
    dataIn = new FileInputStream(blkfile);
    
    if (!skipChecksum) { // 如果检查block的校验和
      // get the metadata file
      File metafile = new File(pathinfo.getMetaPath());
      checksumIn = new FileInputStream(metafile);
    
      // read and handle the common header here. For now just a version
      BlockMetadataHeader header = BlockMetadataHeader.readHeader(new DataInputStream(checksumIn));
      short version = header.getVersion();
      if (version != FSDataset.METADATA_VERSION) {
        LOG.warn("Wrong version (" + version + ") for metadata file for " + blk + " ignoring ...");
      }
      DataChecksum checksum = header.getChecksum();
      localBlockReader = new BlockReaderLocal(conf, file, blk, token, startOffset, length, pathinfo, checksum, true, dataIn, checksumIn);
    } else {
      localBlockReader = new BlockReaderLocal(conf, file, blk, token, startOffset, length, pathinfo, dataIn);
    }

      在上面代码中,返回了BlockLocalPathInfo,但是很可能在这个过程中block被删除了,在删除block的时候,Namenode会调度指派该Datanode删除该block,恰好在这个时间间隔内block对应的BlockLocalPathInfo信息已经失效(文件已经被删除),所以上面这段代码再try中会抛出异常,并在catch中捕获到IO异常,会从缓存中再清除掉失效的block到BlockLocalPathInfo的映射信息。
      

    • 如果Client非集群Datanode节点,远程读取block

    如果Client不是Datanode本地节点,则只能跨网络节点远程读取,首先创建Socket连接

    s = socketFactory.createSocket();
    LOG.debug("Connecting to " + targetAddr);
    NetUtils.connect(s, targetAddr, getRandomLocalInterfaceAddr(), socketTimeout);
    s.setSoTimeout(socketTimeout);

      建立Client到目标Datanode(targetAddr)的连接,然后同样也是创建一个远程BlockReader对象RemoteBlockReader来辅助读取block数据。创建RemoteBlockReader过程中,首先向目标Datanode发送RPC请求:
      

    // in and out will be closed when sock is closed (by the caller)
    DataOutputStream out = new DataOutputStream(new BufferedOutputStream(NetUtils.getOutputStream(sock,HdfsConstants.WRITE_TIMEOUT)));
    
    //write the header.
    out.writeShort( DataTransferProtocol.DATA_TRANSFER_VERSION ); // Client与Datanode之间传输数据的版本号
    out.write( DataTransferProtocol.OP_READ_BLOCK ); // 传输操作类型:读取block
    out.writeLong( blockId ); // block ID
    out.writeLong( genStamp ); // 时间戳信息
    out.writeLong( startOffset ); // block起始偏移量
    out.writeLong( len ); // block长度
    Text.writeString(out, clientName); // 客户端标识
    accessToken.write(out); 
    out.flush();

    然后获取到DataInputStream对象来读取Datanode的响应信息:

    DataInputStream in = new DataInputStream(
        new BufferedInputStream(NetUtils.getInputStream(sock), bufferSize));

    最后,返回一个对象RemoteBlockReader:

    return new RemoteBlockReader(file, blockId, in, checksum, verifyChecksum, startOffset, firstChunkOffset, sock);

    借助BlockReader来读取block字节

      我们再回到blockSeekTo方法中,待读取block所在的Datanode信息、BlockReader信息都已经具备,接着就可以从包含输入流(InputStream)对象的BlockReader中读取数据块中一个字节数据:

    int result = readBuffer(buf, off, realLen);
    

    将block数据中一个字节读取到buf中,如下所示:

    private synchronized int readBuffer(byte buf[], int off, int len) throws IOException {
      IOException ioe;
      boolean retryCurrentNode = true;
    
      while (true) {
        // retry as many times as seekToNewSource allows.
        try {
          return blockReader.read(buf, off, len); // 调用blockReader的read方法读取字节数据到buf中
        } catch ( ChecksumException ce ) {
          LOG.warn("Found Checksum error for " + currentBlock + " from " + currentNode.getName() + " at " + ce.getPos());         
          reportChecksumFailure(src, currentBlock, currentNode);
          ioe = ce;
          retryCurrentNode = false; // 只尝试读取当前选择的Datanode一次,失败的话就会被加入到Client的dead node列表中
        } catch ( IOException e ) {
          if (!retryCurrentNode) {
            LOG.warn("Exception while reading from " + currentBlock + " of " + src + " from " + currentNode + ": " + StringUtils.stringifyException(e));
          }
          ioe = e;
        }
        boolean sourceFound = false;
        if (retryCurrentNode) {
          /* possibly retry the same node so that transient errors don't
           * result in application level failures (e.g. Datanode could have
           * closed the connection because the client is idle for too long).
           */
          sourceFound = seekToBlockSource(pos);
        } else {
          addToDeadNodes(currentNode); // 加入到Client的dead node列表中
          sourceFound = seekToNewSource(pos); // 从当前选择的Datanode上读取数据失败,会再次选择一个Datanode,这里seekToNewSource方法内部调用了blockSeekTo方法去选择一个Datanode
        }
        if (!sourceFound) {
          throw ioe;
        }
        retryCurrentNode = false;
      }
    }

    通过BlockReaderLocal或者RemoteBlockReader来读取block数据,逻辑非常类似,主要是控制读取字节的偏移量,记录偏移量的状态信息,详细可以查看它们的源码。

    DataNode节点处理读文件Block请求

    我们可以在DataNode端看一下,如何处理一个读取Block的请求。如果Client与DataNode不是同一个节点,则为远程读取文件Block,首先Client需要发送一个请求头信息,代码如下所示:

    //write the header.
    out.writeShort( DataTransferProtocol.DATA_TRANSFER_VERSION ); // Client与Datanode之间传输数据的版本号
    out.write( DataTransferProtocol.OP_READ_BLOCK ); // 传输操作类型:读取block
    out.writeLong( blockId ); // block ID
    out.writeLong( genStamp ); // 时间戳信息
    out.writeLong( startOffset ); // block起始偏移量
    out.writeLong( len ); // block长度
    Text.writeString(out, clientName); // 客户端标识
    accessToken.write(out); 
    out.flush();

    DataNode节点端通过验证数据传输版本号(DataTransferProtocol.DATA_TRANSFER_VERSION)一致以后,会判断传输操作类型,如果是读操作DataTransferProtocol.OP_READ_BLOCK,则会通过Client建立的Socket来创建一个OutputStream对象,然后通过BlockSender向Client发送Block数据,代码如下所示:

    try {
      blockSender = new BlockSender(block, startOffset, length, true, true, false, datanode, clientTraceFmt); // 创建BlockSender对象
    } catch(IOException e) {
      out.writeShort(DataTransferProtocol.OP_STATUS_ERROR);
      throw e;
    }
    
    out.writeShort(DataTransferProtocol.OP_STATUS_SUCCESS); // 回复一个响应Header信息:成功状态
    long read = blockSender.sendBlock(out, baseStream, null); // 发送请求的Block数据

    文章出处:http://shiyanjun.cn/archives/962.html 时延军

    展开全文
  • 文件系统:一个可被挂载的数据称为文件系统,每个操作系统可以使用的文件...文件系统通常将档案的属性和权限放置在inode中,至于实际数据则放置到data block中,另外还有一个超级区块(superblock)会记录整个文件
  • 打开文件open()函数的使用方法详解

    万次阅读 2017-12-22 22:38:35
    头文件:#include #include #include 定义函数:  int open(const char * pathname, int flags);  int open(const char * pathname, int flags, mode_t mode);...参数 pathname 指向欲打开文件路径字符串. 下
  • HDFS-Datanode关于block文件的管理

    千次阅读 2014-07-09 15:46:26
    数据文件真正存储的地方是在datanode,当用户需要填充文件中某一个block的实际数据内容时,就需要连接到datanode进行实际的block写入操作,下面我们看一下datanode如何管理block,以及如何存储block。 Datanode是...
  • Quartus II 之Block文件编程与时序仿真

    千次阅读 2013-10-27 15:52:06
    一、建立block文件bdf 1.QUARTUS 2 启动à New Projectà然后一路next,选择好芯片型号EMP240T100C5Nà选择好仿真器:Custom Verilog HDLàFINUSH   2.FileàNewàDevice Desing Files[ BlockDiagram/Schematic ...
  • HDFS文件块(block)大小设定依据

    千次阅读 2019-04-03 12:03:56
    最近看到这个面试问题,CSDN搜了半天也没有确切答案,查询...我们在HDFS中存储数据是以块(block)的形式存放在DataNode中的,块(block)的大小可以通过设置dfs.blocksize来实现; 在Hadoop2.x的版本中,文件块...
  • iOS 打开系统文件APP,从文件中读取

    千次阅读 2020-02-22 21:50:59
    公司是做文件工具类的 App,因此在 Apple 发布新的 iOS 11 后,我司加入了需求,需要允许 App 沙盒内的文件使用 ...在你的 App 内的文件可以出现在 Files 里面之前,你必须保证你的 App 是支持 Files 中打开并且...
  • 磁盘inode在文件创建时就已经创建,存放在磁盘上,内存inode 在文件打开时才创建,存放在内存中。 format.cpp——格式化 //初始化硬盘 memset (disk, 0x00 , ((DINODEBLK+FILEBLK+ 2 )*BLOCKSIZ)...
  • vivado输出block design 的tcl脚本文件

    千次阅读 2018-08-03 17:28:13
    在TCL控制台输入如下命令将BD导出为tcl脚本: write_bd_tcl E:/dp_tx_ex/bdtcl.tcl,红色框内是tcl脚本导出的路径。
  • (1)文件分割后,会有一个 文件 --> block的映射,这个映射是持久化到硬盘中的,具体的映射关系表是在FSNamesystem.java中构建的(该部分的构建使用的是FSDirectory.java的功能,filename - blockset);...
  • 为什么HDFS文件块(block)大小设定为128M解析.

    千次阅读 多人点赞 2020-10-11 23:42:31
    Table of Contents ...HDFS中存储数据是以块(block,这只是一个逻辑概念)的形式存储在DataNode,block大小可通过设置HADOOP_HOME/etc/hadoop/hdfs-site.xml中dfs.blocksize实现(设置时先stop集群,修改.
  • debugfs 查找文件的 inode block 信息

    千次阅读 2014-11-01 22:38:07
    //vi 打开tem.zip 删除几行后的文件信息 block信息发生了完全的改变 [root@localhost jz]# ./my.sh this is jz shell Please inupt file name: tem.zip Inode: 789463 Size: 98345 EXTENTS: (0-24): 442368-442392 ...
  • 前文已述,Ext4文件系统将磁盘空间划分为若干组,以这一组为单位管理磁盘空间,这个组叫做块组(Block Group)。那么为什么要划分为块组呢?其主要原因是方便对磁盘的管理,由于磁盘被划分为若干组,因此上层访问...
  • F12打开console,发现每次从http网站下载文件,console都会出现下载被blocked(屏蔽)的提示: 原来chrome认为 非HTTPS网站都是不安全的,自动屏蔽了 来源于http文件的下载。 chrome果然是大佬,说屏蔽就屏蔽。 ...
  • hadoop 查看文件副本数和block大小

    千次阅读 2019-03-08 12:01:48
    当向HDFS上写文件时,可以通过设置dfs.block.size配置项来设置文件block size,这导致HDFS上不同文件block size是不同的。有时候我们需要知道HDFS上某个文件block size,比如想知道该文件作为job的输入会创建...
  • 命令: debugfs -R "stat " $disk 例子:假设磁盘中有一个72MB的文件"999" 1)先查看文件的Inode $stat 999 2)查看文件所在的盘符 $df -h 3)查看是否连续块 ...可以看到共有18431个连续block,每个
  • 查看Block文件: 1.生成创世区块: configtxgen -profile TwoOrgsOrdererGenesis -outputBlock ./channel-artifacts/genesis.block 生成的文件位于目录 channel-artifacts 下 2.将 Block 详细内容导入到 json ...
  • 为啥集群小文件治理那么重要,你真的懂吗?

    千次阅读 多人点赞 2021-06-01 15:43:15
    文件是 Hadoop 的常见挑战,如果不小心处理,它们可能会导致许多并发症。Apache Hadoop 分布式文件系统 (HDFS) 旨在存储和处理 TB 和 PB 级的大型数据集。但是,HDFS 存储小文件效率低下,导致 Namenode 内存利用...
  • 在HDFS中,提供了fsck命令,用于检查HDFS上文件和目录的健康状态、获取文件block信息和位置信息等。 fsck命令必须由HDFS超级用户来执行,普通用户无权限。 [hadoop@dev ~]$ hdfs fsckUsage: DFSck [-list-...
  • 1.打开 codeblocks 图标 2.点 creat new project 再点 3.把文件集合,复制到新创建的文件夹里 比如下图文件全复制到新的文件夹里 main.cpp 也覆盖 再打开 文件夹名.cbp 4.右键点击 文件夹名 下图案例 文件夹名test...
  • 通过hadoop fsck查看HDFS中jdk-6u24-linux-i586.bin文件对应的block块以及block块的分布情况 [root@hadoop local] # hadoop fsck /jdk-6u24-linux-i586.bin -files -blocks -locations -racks FSCK started by ...
  • 索引节点的提出对于存储在磁盘空间上的文件,实现快速的读写和索引是影响用户使用体验的关键。和PCB类似的文件控制模块FCB提供了足够的文件属性,在搜索匹配过程中,显然文件名匹配是搜索过程的关键,并且是唯一...
  • 在pyspark中,使用数据框的文件写出函数write.parquet经常会生成太多的小文件,例如申请了100个block,而每个block中的结果 只有几百K,这在机器学习算法的结果输出中经常出现,这是一种很大的资源浪费,那么如何...
  • 为了避免对文件、块、片理解有误区,解释一下三者关系 1、一个文件从本地被上传到HDFS时,会进行分块,块大小默认是64M,同时会产生副本数保存在其他datanode上...3、block是在物理内存上进行存储的,是真实存储在hd...
  • ERROR - Application run failed java.lang.IllegalStateException: Failed to load property source from location 'classpath:/application-prod.yml' at org.springframework.boot....晕,第一次用yml文件
  • hadoop修改block size,并上传文件

    千次阅读 2016-04-10 18:44:54
    修改hdfs-site.xml    dfs.replication  1      dfs.block.size  5242880   上面是修改成5M的,需修改成1024整数倍5M=5*1024*1024 否则会无效 Name node is
  • 转自:...谢谢 今天在给CentOS Linux release 7.1.1503 (Core)系统的跟分区扩展逻辑卷的时候, ...lvextend之后显示lv空间已经增加 ...然后我需要同步文件系统,一开始使用resize2fs后来看到xfs

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 670,025
精华内容 268,010
关键字:

怎么打开block文件