Linux File System

时间：2022-09-26 14:45:03

目录

. Linux文件系统简介

. 通用文件模型

. VFS相关数据结构

. 处理VFS对象

. 标准函数

1. Linux文件系统简介

Linux系统由数以万计的文件组成，其数据存储在硬盘或者其他块设备(例如ZIP驱动、软驱、光盘等)。存储使用了层次式文件系统，文件系统使用目录结构组织存储的数据，并将其他元信息(例如所有者、访问权限等)与实际数据关联起来，其中采用了各种方法来永久存储所需的结构和数据
Linux支持许多不同的文件系统

. Ext2

. Ext3

. ReiserFS

. XFS

. VFAT(兼容DOS)

..

每种操作系统都至少有一种"标准文件系统"，提供了一些文件操作功能，用以可靠高效地执行所需的任务，Linux附带的Ext2/3文件系统是一种标准文件系统
不同文件系统锁基于的概念抽象差别很大，例如

. Ext2基于"Inode"，它对每个文件单独构造了一个单独的管理结构即"Inode"，这些元信息也存储到磁盘上。inode包含了文件所有的元信息，以及指向相关数据块的指针，目录可以表示为普通文件，其数据包括了指向目录下所有文件的inode指针，因而层次结构得以建立

. ReiserFS广泛应用了树形结构来提供同样的层次功能

为支持各种本机文件系统，且在同时允许访问其他操作系统的文件，Linux内核提供了一个额外的软件抽象层，将各种底层文件系统的具体特性与应用层包括内核自身隔离开来，该软件层称为VFS(Virtual Filesystem/Virtual Filesystem Switch 虚拟文件系统/虚拟文件系统交换器)。VFS既是向下的接口(所有文件系统都必须实现该接口，以此来和内核通信)，同时也是向上的接口(用户进程通过系统调用访问的对外接口 实现系统调用功能)

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAgoAAAEgCAIAAABafMzPAAAgAElEQVR4nO2dPYgdV5r+K7hJ0YGhg4IObBAUswgvDroMChrhoBrDYImBKe9IgViDcGnoYGQMoiRHWiOvcck46DED05QM1mIbOlHhDnaXDhbMdLbqqEA32YENq9mwJz71D5657/+ovm7dr/q49/kFze26deue+rjvc877vuc9RkYIIYQUMLpuACGEkD5CeSCEEFIC5YEQQkgJlAdCCCElUB4IIYSUQHkghBBSAuWBEEJICZQHQgghJVAeCCGElEB5IIQQUgLlgRBCSAmUh56SpqlSSv83SRJsSdO0u3YRQjYFysMSSNM0riUMQ2dGDMOwLEv+NU1TthiGMevRigRBUN/mIrpcEULWHspDJUmS6Mbxxx9/tCuA7a7BNM2cdbZte1aDHkXRHDJTQ32bi7z55pv6WTuO4/t+qZBwfEPIGrCJ8pCmafQ6juNYBYpG3zRNtwzP89Jp5NrQh5741DbnuHPnjn7W9XKoX8kwDHMXPI7jrs+eEDKFNZeHUMNxHHNCqVGDoddJkkS3j32w6f2hRkjCMJRrWDVMkXvxwQcfyD3iFSakP6yPPCRJEgRBEAR/+MMfqmTAdV1fA/50oeszWFvU64RhKLegKB64ccHr8O4Q0j6DlAdYmSiKfN+3LKtoXDzPE8tCP8ZQiKJI7pr5OnJ/RVeQx0XZIGR1DEYe0jQNggD+iqKPOwiCMAyTJOm6mWQlICwfhqHrurmwkLgEoygqDfMQQuaj1/KQJEmSJK7rigvCNE2kzSDC2XNbEIZh/dhFKXV5eVn6lsxyKH5kpi6zUqqrq7S63j3GjsD3fdu29UGk4ziu6/7www89fzwI6Tl9lIckSRBJ1n/wMLXDGh/4vm+aZk2bXdfVM1wllotzD4JA9kSWLfrOUEdcEMF13VJrGASBYRhRFE1tLcZnjuMsyx3neZ7ruks5VBP0KSaiFriqzLUlZA56JA9QBZlG4DhOEAQYQHTdtKYopXzf1zM4MZFN7+fqRt+27bt378L0I2sW5xuGoS4PMHm2bWNjEASu6+aybPX9j4+PEf7F9xqGYVmW3t12HEcaDI8/OuAAMiwd/+a2NY5jGdXhsIZhhGGId5E70E60QCn1yy+/4MrgccK4kzm1hDSnF/KQpqnneaIKvu8PtK8HWwxVy82NQOAEqVOyv23bx8fHeO26rm65TNPMGTIcHObV8zzbtvV3TdMUy3t4eIjBRCm+74vJzrIMW6A9klykq4UuPEopfY6Ibdt6s7ER5yhpxDj3IAh834f+LetqN0TOWuZqWJYF7WRkm5AaupcHeGAMw7Bte+g9O92CZ1mGJM4aG+R53uHhIfY0DENOP0kS/V/94AjC5+QBow2xvIeHh9gBO8NS27YNDTZNs9gSHEGajUEPpAJpplmWXVxcIBcAU0Ag6lB0fBBmVz8Feasn6M3GkAL5zV23i5A+0qU8XF5eokNn2/Z69ONEHmBPYWel651ztmRZZtv2aDTSczf11zD3aZpWTeXL5X3m5CGb+I6QBur7PnbTdUVySXEjnElxJ12cRB4ODw/1bwEIn+A1xhM4IIYjeoYxAipNoiAtAOWW8YTjOAPyYRLSDl3Kw8nJSX/sxVIQeUDyTDaRBJge/TUQ5xKEJOdcyhks+HlwuRDE1t/V++mPHj2SqxrHsXhUiq5/KJnYbnSlISRFedjf3y+OBqBA0kJEjIIgsCxLspB938cElCAI+uY2TNNU4hNtBtIJ6T9dysPBwYHelV4D9NEDlAA+FphXOOL1/UUe0jTNeZNy8pAkifTrPc9D7r9e/0P35Ny6dQuGGKAxtm3LFs/zdJ2AOGGfKIpyri2RhytXrtQ7i8S5FIahaZppmkKc+iYJpUAklpi4RcjQ6Vge1mxEj+p+eC29UYwkSg2lbdvvv/8+grewznomkr4nYgPQBtM0SzOjpBd/69YtxB70mrIyZQTH0ROo5ODiEUKXH+/OKg9pmiJGjVQlKA08OT23vMgfg7B13RZCuqdjedDTeNYAzODFa/hzsBGZPEXfhW3bn376aRAEEnaGBwauHt1IiVmXwIZsx2F1ob1161bOwEnDoFJ6bpg+LsmyDEMTPUYyqzyEYSgrVaDZMrej/2YXN2KdHJ6EzE2X8vD999/DQ9JhG5aLbdtippFJmU2yZYp9Urh0Li4usgrnkvh/MEpApx4bEfvVhwW6Ubtz504uxiA9d6WULiQIkyCZWMYraZpiHqK0BPKwt7c3VR5wjvqciaE4l0A/E64I6YSOE1vhRcGSAN22ZHFgWXRTKFYSsdnc/nEcW5Yl64NWxR4wCwEzzkQeIDlwhmAooNcbLw5Tqhw7iFsgjSeX2IpQNrxDaPyTJ0+KPesoivB1UIIkSYprZuA1xiU9D/9y9ECI0P28h/F4fHh4uLu7u7W1tbe39+DBg+Pj46pKRH3m448//uabb168ePGHAteuXfN9Hy9u3ryZZdnFxYVt26enp/isyEOapu+9997e3p4ee4DdF3k4PT09PT09OTk5Ojra3t7e29s7PT394osv9vf3z87Ovv/++2+//VY+Ox6PHz9+vL29XSoPoii6PGRZ9vz58/F4jNdHR0d4/be//e3Ro0dXrlzZ29s7ODi4f//+H/7wh/v372MA9PDhwz/96U+52t0//vijYRh//etfe144fTweHx0d7e3tXb16VSYqErLhdC8PArzq4mRHjHQzp7aWVitCCubUz8ZxnBNXvYpGDYv06zEtubQxhjZPsG/gkUOkp746FiEbSI/kQUCii76Gs1TaGJAXm2RZBg9Y163II8UHjUlN+DXwbRKydPooDwIquyFHU5cK13WxugPVgjQkTVPUOtQrL6E6VtdNI6Sn9FoedFDWFBWEcrW+pWgz6zYT4fLyEo8EaqRLwUfM68Y6sl23kZBeMxh5yIEJyUge1cMVyPJ0XRezf7tuJmmVJEn0+uQy1w+JW3weCJmJocqDDrI8USvC87ytrS2RCsmw9DwvnMBu43qQpqncU6k9LnzwwQe5fF9CyEysgzzkQPYkxhbAeB0pdCpLEQDakd6CYDIwNfTbinsN+eetJGRx1lAeakB16yrZ0EElDB2ZB0BWBFa4E3SfYc3doRIQsiI2Sx5q0PunuS5q1XILtm3r5gwLcNbQ9SmulvpzV0r5BfQUA1nyU5Bp24gkd31+hGwclIemhK/j+771OjVjEenzegXu379ftepnFQueyKxfJ3z88cfF9gPd0FdhlYGLicmP1ABCegXlYTlgVZwqxFtSRALpzXEXY9avK6X0XASs5Jyj61tECJkNykPHvHr1Km6M67rOYmA9uFLgw2lI15eNELJyKA+EEEJKoDwQQggpgfJACCGkBMrD8EDFiPp9UF6infYQQtYSysPwMCarWNeARNu1n2xBCFkdlIfh4ThOvTxcXFxgltk6reNNCGkZysPwwBrONfPjzs7OZIICBxCEkPmgPAyPqc6lp0+fijwEQdBawwgh6wTlYXjA7tfMTdvf39enN7fZNkLI2kB5GB6w+zWJSTs7OyIP9W6oJkRRhAUVTk5O9O255CisvrDIFzWBS/oQ0hqUhwGAarISRcjJQ26BozAMc/WRmgeokySRIqme50mpWpRR+umnn/SdsUKnaE+SJKZplvqywjA0TROWXSkVBAEkB1/0xz/+URcwz/Ny63DoMN5OSGtQHgZAkiRio5VSIg/o1BuG4fu+7FwsutdwAKFbYSlAWzVGQZMwXJBV27CSq+/7kBb9S6ElaJ7jOGEYop2+7+/u7urfgu14naYpynrj3ziO5UsJIauG8jAMatbG0aMLSqnS0uIzmVSojm3bGJREUeR5Xi7U4TiO67pKKVhz0zRR09s0Tal5rstDkiRoQ5IkODKGAmma3r59W5cH0zR1tXMcR3coUR4IaQ3KwzCAMS1FN6ZVuzUMUOvmHh18/GtZlm7BoQRRFOFdeLdc14VlL13NWxZEwrADubn4oq2tLf3gnudBNrAirGmacRzLv5QHQlqD8jAMqoYFsKS5fX7/+9/D+KLjjxBCk6BukiQYN9i2LVGHon9JjHtOG5IkSdPUdV39U5AZHBb/2raNwQQ+XupcwuhExAn/YghFeSCkHSgPg6F0ZJDzLMGtLzqB7fDnNFykIU3TJEk8z7MsC+OSJEkcx9E/niRJHMcIM2ST/j78S5jRjbaJIKHXj5ByFEV4F5phGEZu9ICouDTGNE39XcoDIa1BeRgMFxcXesaqYRjb29vn5+elO+vyAJpMn3727NnVq1dHo5Fpmh9++OHNmzdv37798OHDq1evbm1t/du//Rt2+/LLL7e2tnZ2dh4/fvzRRx89efLkyy+/HI1G9+7dM03zxo0b4/H4+PhY/0ZJavr444/ffvvtTz/9dH9//969e7u7u7nYw8cff3zt2rWzs7Ozs7PT09OdnZ1nz56dTaA8ENIalIchkUtarZn6UJSHhqRpitTSOI5N0/Q8LwzDJEmUUqenp9gnCALkUIkAIKcInf3S3FZsx5jDcRzbtl3Xxagi51xCAEMWZ0XmEnJhfd+nPBDSGpSHgSFO//p01fnkQSkFTxG8RrZte54HI26a5sXFhb4nVhX1fT9NU7iM6uVBkq8gEnBeGYbx8ccf5+RBd2Qxc4mQrqA8DAwZQOgJS0XmkAelFKw2VAe2XrJRHce5efMm9oRZN01TMpogJFmWYUZblmUYK8jBoWqIN8RxjCgFpkp8/fXXIg9IVdJbRXkgpCsoD8Nj6tAhm10e4FPSY8JwLomJR3w7y7I4ji3LEhuNAYeIiu/7GE/A+svxEccOw9BxHBxfJlUcHBxAHjAZIjf4gDwopRAzpzwQ0hqUh+Hhed7UeQyzyoPe04fFRzqsHl4upsYiERbz47AFAwvJTdJ3Rj5VLoHK9/3RaISNURTlvjGbyAP0RnxTzc+LEDI3lIdBMjUNCbmni3wFjHL9PujR5zbGE4qNLJ17oQ9Eit+IoQNeB0HAoQMhrUF5IIQQUsJ0eYjjOFwZqJeA1MkWzpYQQkhDpsuD+HxXjTkQPM+rKjfdN1p4gAgh60ojeTg6OmqhKVV0bWOn4/s+lAOJod2qlzmZGFGluO2IfT2Y9ICex40bN/xegvSq5dLh74iQWRmAPJBZefbsGXx3pe+iHF7PCYLAmoAcWaTP9pPmuoi8XkIGAeWBkEWJ4zhqAAqKdN1YQppCeSCkJbBSXtetIKQplAdCWoLyQIYF5YGQlqA8kGFBeSCkJSgPZFhQHghpCcoDGRaUB0JagvJAhgXlYZk0mfo0tc4dWVcoD2RYUB6WiayKk1VIhVLKMAy9wNTl5SVe6KVJc2D9nKllqdI0xQqd+NfzvJrVRnOtSpIE0+Vc1/ULCw1hNQi8jqIoYLmOuaA8kGFBeVgmtm2bpoml0CzLKtoCyINeavv69etZlgVBYFSvZICVEqZaFt/3cRAcxzTNoqHPtHVA4zj2PA8rP0uzHccpNsOyLFlhIgzDnMKRhlAeyLCgPCyKPi0WZjQMQxTtSZIEf7GnrHcWBEEURein7+7uZlmGihE1jiks1Cw75I4MYOKzLNvb28tq5QGDDCwRahiGaZo15h7SpZS6uLjAaZqm6bpuFEVYmIhS0RDKAxkWlIeFQFfadV388qXYnOu6WD7TmCwKDYPueZ5hGLZto8Puuu6tW7eyiTzIYZMkQbE/LM4MK4xvQZEfx3FkVWe9JVjDB5Ij8hBFUWnAIwgC0zQ9z5N1QG3bzu2ZpqlhGGEYYgTjui6K+uE1FI6V5hpCeSDDgvKwEL7vm6aJ12mamqaJ0QMsL7rzusGFcymKIqUULD5sa04ehCRJTNOUlZmhAaXmGFYb8YOdnR38a5om5CQ3jMBhIWxBEKDgHXRL9ywhmIHxgeM4V69exTlalhVFEQcNs0J5IMOC8rAQGB/ohbIxaAAwo/r+kAfYXENbjblKHrIsc11XTDbkoXQfNAOvT05OlFJVzqVs4i/CDig4att2MY4dRZFebfQ///M/ITYIZTuOU++VIjkoD2RYUB4Wojh6MAwDPfHSAs5icIMgwOgB22vkAZ4lvC61+IhnwFijDciGqpEHaTCCJRCGOI5938/FpcMwRJvDMHz69CncSohm4xurmk2KUB7IsKA8LATkAd4emGYEDLBEQRiG4llCPWdoA8wx5AGmHL3y0q+AIwheo9KUIaxeh5bA4qdpCpuOuEKSJBJgkMZgwIF9EBSR5umiEscxtqRpenBwAOXD4CMIAqUUk1ybQ3kgw4LysBBwLjmOg2xRwzDSNIX1xLsyXQDDhTAMZbSBDvg777wDj1NVTx9RColkFHeA3Ue0I01Tx3G++uorcV75vo90Iz1igWaYk+XtMDiQrCQRKhkPYc8///nPco4QwuVdyI2A8kCGBeVhIa5fv37z5s1PP/10Z2fnk08+EXnY2dnZ3d29efPm8fGxvr9SajQavXz5Mssy27ZHo9GPP/7461//ent7+/3338/tLNy/fx/9+m+//Vam0eWAPOhbapxLl5eXv/3tb9944407d+6Ixb93797du3e/+eabX375RfYcj8fj8fiXX345Pz//n//5nz/+8Y87OzuXl5eUhzmgPJBhQXmYHyR9oleOfro+ekC6EVJCsT+yfcS5FMdxGIa3b9/2PA9emqLvKEkSJLNiPTJ05EunQzeXB/T9JaVK5CGbzL+TCXppmmJ4gfjE5eWlZVlQBZGHYriCVEF5IMOC8jA/SEzCBGn4f/QsJnkh8WeZg5ZlGZTDtu2PPvoI78I0izygvgWssAiMUgoihOPIkbPG8gDvE3xNaAPCCRKZgObJXA0ELdCAg4MDycSFwOAUKA8NoTyQYUF5mJ85vCsy1TlNU8R7S3fDTIUas1ucdlAqD1MNN4Ys9RO25Rt//etf5z4IKA8NoTyQYUF5WFuWOyNBKVUV9iANoTyQYUF5IKQlKA9kWFAeCGkJygMZFpQHQlqC8kCGBeWBkJagPJBhQXkgpCUoD2RYUB4IaQnKAxkWjeTh6tWrQUfEcVz6umqfLMu++uqrMAxXf+kImQ3KAxkW0+VByre1j0wPzm3pHBS1nrqb3x1RFDXZLUkSTJ8OgqD4Fsp+qL7Sws9juVAeyLCYLg8dghqi8q9SKhwmvu9bQ6Oodm+88cYKpHZOTNOUNVZt2/b6TRiGnudZlkV5IAOi1/JAOgRFAHUuLy+LGwdBEAR2P/AmBd4J6T8dyEMQBHotuVKUUqzkQwghHdKBPBiTqqU1RFFkTGplkxy2tgppFVgkrp32DJGqYoiEEKGn8oDAb8AFZ8owDMOatsKzbdtTL/JmkiSJZVl+7SrcwPd9PoFkk+mjPMgalobB0EgJU+UBq7kZLLVdhu/7TfQ1m6xp0UKTCOknfZQHPWeU3bciU63b+fm5XMDWWjUUGsoD3Ju8gGST6UYeDMMIK2au6UMHwzDYfSsy1bodHh7KBeQAIodSqok8SGovn0CysXQmD1FhtWSApY91aOByTLVuN2/epL5W0WT0oD+EpmkyRYJsJi3Jg6xXnE2cS/hXKaXnkCililOjaeByTLVu29vb1NcqmsiD53n6BWwSxyZk/WhDHuAvcl0XSiDOpfPzc8uy9IlCxaEDDVw2mQWi66t+TXIJrEmS5K4erZvOVHlIkiTXR2kSxyZk/Whp9GDbtjEphICfnOu6cO/qweeqQkYbbuCgmq7rQglwTaIoQi1C4/UJIrmer0H3SJbFcSwimpOHNE1zfs7iBWQHhWwmLcmD5IHk0B1HiBmWwu6b6KvrumL05eKI9U/TtPQCVkV6NoQoikzTtCwrjmNdHoIgwGWcegHp4SQbSHuxh9J6q/rQAb9bwzBc18XOKFPD7lumXZwi+gzqKhm2bbvDxndO8fEzTVMeLd29GYZh6QU0TZMTrcmm0V7mUtHAbW1t6U4P27Yty8KPEAN8+JRg8ja8+1alr4Zh6GYLJu/999+XaXHw19G6lbqMihdQBmdFNtzDSTaQ9uShaOCuXLmi76DPhIAkyA8yl+C0mUhvV0cfOiDvCxcNcR1sh2tlapmm9aZKX23bLnqWfN+XYUSSJJDYDR+BkQ2k1XkPBwcH+i/zX//1X6v2zMkDybLs/Pw8l7G6tbVVpZq6PGRZNtD1c5bLRx99lNOG7e3tly9fyg7j8fjk5GQ8HmeFWdPj8fjo6Ohvf/tbN00npAvanhand4HPz8+rdqM8lJLzjFfNPM8K8kBAbgBRE7FnUQ1C2n76kYhpvJ5vU4TyUIpSSvS1/gJSHkrRA2D18RjKAyFtP/2SvVpfa4/yUIXMHKxfd4zyUIqePF1/ASkPhHTw9Pu+33A5IMpDKej51q/2Q3moAgOIqalclAdCunn6p5bpRp7Jhs91qML3/YYFR9tpz7DA8GtqGhLlgRA+/etJFEU1gesNx3GcJtPITdPkintkk5kuD2mnFBugl3qtQo/Z5v4lpCFRFHG9brLJTJeHqjJ57VD8dsuyHMeR1VpKsSzLtm3HcfBxfMRxnE5+7VEU+b6flOF5nuM4qLXXT9KJgz5JkouLi/avHiGkKxrJw8HBQdwznNkxOircJBJVL2n9BLWJkE27vb2dtK6vSZLYc/H06VM8Kp7nycYoiqIosm07CIJOntv2LyAhc9NIHo6OjlpoykpJ09ToTh4cx4GPq9uhwILs7u62fwHjODYMA2OsRcCEOMuyaqoqtcCGlw4jw4LysHJg2tr/3qXz4MGDruQhXbjiFoJViEKtJEo2jSRJ4ORcxlUhjXj16hVeME1jPigPK4fysAjLkoc+4Lou5aEhaZoGFViWZTZjNBrhhWEYDT8yFdd1gyCwbdv3fb1Va6lAlIeVQ3lYBMrDOqE0kLIh7OzsFH1xpQY6Z5erWOIzU6pVNSqln4LruvppysLAg0inpDysHMrDIlAehoied+5NKM1CFO7duxe+ziAMaCmYdQQwiVVH9MM0TU/jp59+whXruvn/H8rDyqE8LALloZ4wDDu/OJJzEcexnghQ1IAgCCKNbpvdIfpFEP3Y2tqS/AVcxjAMcWG7usWUh5VDeVgEykM9yJb2PK9lIwKzFYZhbhISEojDMJRc3taaNHTG4zGuGGIbQAInSIDEVM0kSdoZWlEeVg7lYREoD/XoS4DAWbHSaxXH8UcffSRV5cVsYUpHwlkdywY5b1EUyfwtiDFm/rquu9LJNJSHlUN5WATKw1Ry0y1N08QEwGUdP0kSRGLxRVeuXHFdF93Y9bgvwwKuvCAI8DjhjluW5Xne0l12lIeVQ3lYhA2RBz2YOStVZW+uX7++SGtFFSQDB0OTy8vLRQ5LlkuapnEcI7gt/r1lxfZXIg+e5xWTvfQ132tAXMs0TV0GlVLIfKhfwqWGIcoDYn25fOrmA0n8vOf43iooDwtSJQ+Xl5e5bMhlgTz9WdsZhqHMLXccJwiCDpOI5vacKKVqliteS5AuLDqB23d6ejr3AVc1esDjLv9iDdGaH7l40JRS6LDk5AQdmbkf08HJQ5Ikeq8QFydJEvxrWVYcx7oLWBKuPc+7uLjIpWAvZcjZc3nI5dEvxaKpAvpb0kdr+F01o4cwDJvk8peir9+us7W1Natll8VWoQrNP7gioFIyUaDqUuNe+L6PKAg2JklycHBQ3Dl3NAGiWDW7TZ+ucf36dVyl4mPp+75+hK7KgGaTuRqwpSgJOsdBWpKHLMuiKKp6UrHEozyO8WS9TF0hYC5nbYYwOHmQzxra0mZYo0aGUHKh5Co5jmPb9qNHj2S5G+yzIfIgps227e3t7QXPOk1T0Vd43kejEVqC8bFeZrHhyHgVsYdiFSnEqJv3nWEcxZT0JN0Itz53nYsXUFoOGyJ2sFQeRNRziMTqK1QqpSDAnufJV5imef/+/VLvTfG3hnKQcrROBmEvXrzAYzyH5LckD/Lz9n0fKb1xHH/99ddoLoygxNPE6ummcDPlQSklYwK81t1rGEyYpimPHeZk3rp1S/9GxKwWOQXQc3nIJoYSBmJ3d9dceDEf5AXJNT88PER/3DAM6SRin67kAQ+2YFkWkuVnOgium9717hx4EfQHHlai6knWf2XI+xR5mPrwJEkCEaoZbOHXZ9s2oi/FY6IzAc0IwxDBAJwChrM4fvMrsFyiKJrjLq9WHiQZy5ysjZymKXQ4DMNf/epXaCicZbZt41+4TeCPMgwDd30z5SHLsjiOzUm10WLoBclteC39vqdPn+rPwbKypIclD48fP4Y8wFJAONPJAlNIMC8eFtvlcuGxESXAdjyZejezodtzFfIgQwcEJOe40XBB9MGVJKRpigcb5gJdeP1G6MhcAfzQpH6+67rb29v4t+aLYKDqhQEDFNzxNE2vXbtWvOMIjiqlcEcg0rg1SPHqwyTwJEnQPP3praENecDATXo0+MlZlnX37l1swb3XnUsweZLTjWu9mfKQaW6T4hOGiTOyJAN+P+fn59KdRC3xRb5dGJY83Lx50zRNuObRN5SRluRK6J3TZLKwBHbGmeLK47eklPrTn/6UaR1213VxRxr21lchD47jzDFcEPDT69sE5jRNxX7hFmCCRfH5V0qJhZFJGOIi29/fRzSl6ovwblW8AegCjMfjnXfeyT2QuIyYiyAPDHq9kpPWB3kAsKtNFKIl5xI6Avq/hmEcHh7i3yp5yLJMfIILFkMetDyITOaOI90T+OvgWMBbWPRGvKVLOfGhyAPsxWg0QrgL9gIzTjHql1iO/jsRAwR7JGNWefwsy3rw4AG+SIa29R6JYvP6VnOpGCPsG9I3gn+1dB88JOLllw7lo0ePcIuxHTdXR3r6ssW27dwYXQr8QUtKJx4irI0dfN9HpSkYnCRJsF36HH0Al2Vqt6Alech1svCLlcBRjTwopcTMLfLTgitziPKA8TWMmn6Vsom7U8a5sjYyVv3EjwFXbylWaSjygAz97777Tt8ozx70Eq8l+IxvEXGVep/YjlFCEATSocFn9ezPhs3rod/bLCwAACAASURBVDyIVe0bYmSRDiR+/GJPXNQa40XcyjAMDw4OcATshqRPHfw6chuLRjOKIowM8L2np6e5zPtsYqnQ1ZD+nPxy5e8Kr9eMIDRSv097mUu+7+PqwFymabq1tYUfbY08ZJpCLPjTQjx8kSPMx4KhaXnmEEDTr2oxcwkcHx/rwWq9Y7UIQ5GHnKelRh6yyfC0yslQ5fKWo4VhiJvSZKi+iDygmsJ8n62h9Ip1jggDHt0gCJD4a2jITdTH0LIPOqDb29v1wyPf9+vzF+RHJ19ami+O3ynECSilEI5G8/p2hbMG556tSB6++uqr/f39/f39f/7nf3748OHDhw/v3bu3v7//8uXLzz//fH9//4cffsiy7MaNG9evX3/58uXFxcX+/v7Vq1cfP3784sUL3/fffPPN27dv6zbu7t27N27cmKkZOYYlDxcXF48fP0ZsTTbu7e0ZhrGzs3N4eHh+fv7pp5/iMf3+++/1z37++ed7e3vPnz8/Pj7+/vvvR6PRzZs3Fz+R/ssDrs8vv/yib/zss8/0jVeuXBmNRs+fP8+y7OLiwrKs/f398Xg8Go1Go9HR0dHx8fE333xz586dbCIP9+7d0w8YBMHOzs54PJYWjkYj7F9Pc3m4uLh4/vz548eP9/b2RqORYRij0ej4+LjJZ2fi4uLi/v37aP/JycnSjz8HZ2dnh4eHp6enb7zxxt7e3qkGvP94jSHyX/7yF9u2j46Ofv/738uvDO9K5hL2LKWJiTw/P4fn9tWrVzdu3DBN87/+679OT09//vlnSR0+OTn54osv0OxXr17BcN25c+fdd99NkuTNN9/sT+AhyzKl1NHR0fb29ieffFK/56YU1RiicwnOUL3NutsUhbpKayOPx2P9rU0ITaOzBvOhxzAldKlvlJE+sn2wEYt9Sj8U+U7i2NR9enAdIDcGk/wb3t+p8iCTs4wC9eHTBZGEll7lthZT9RB51rdI3SfP84qRucePH9d/RRN5wF1G9x/7X1xcYDAnTwUK58FBgmuIUbssIotnb6U3sQl4qiV6P3X/TZGHQYeme0Kf5WFWkGhY7NPl6l9KVeriBCjJji2+W0WNPMBA54rr6TjNQMZOHMe+73/22Wee5zW/ZTI7TFLMuwXpAPrZIX2gdGc9wxtUzZqWd+HErpEHWFI9JO66Lvy0alLcQXKd9RknSimZEIdOBh42fYpS+0gnoBg4qYLysHIoD4uwCTWXsrKZz8tipmgHhi8iEkjCWdLZzwzGZ4kGRoGlO6OPr2+plweZa10VlsMMBjl9yfLQkwMlszmbZN9kk2lbMlpF7EEmfnciD4jJI2oy0z2lPKwcysMibIg8KKX0eGwR5FPmgCeqig8//FAvMtEcvTFIjUNacMumregXrVlrs7jaRJqm9dEU9PFrTkp/S65J/UXAPrk5hhimFMtrtkCaprdv355b7CkPK4fysAgbIg9CVfihk0dIatXJpELTNKc69EnnIBSH+7W9vT33z5bysHIoD4uwafIgYB6WnlXZbXIkQq9S0lVqXfRtxvUmg8oi+ohzwbtDeVg5lIdF2Fh5EGQw0ZOnaDweB0EgnVNYIigH8v27Kk26UahJDXPpQ+B2yBzvpXwL5WHlFHMqBgrlYUEWmRaHPObltmcpoFQJ0q70zCt3srqc0HVLh4pcQCTO6gvD4Zpj2uAqvprysFqQAEd5mBvKw7CQ6TiYbqIvVYRhtIA0UC5YLSD6jWuCaRzupACtiAFKQhVnRK2IRvLw1ltv6dnHYRhKxjci8v0Hhb1iOpcWgPKwIJsgD0X0nyGugExigNWTSqtF87Ie9z1HzjRhtXCoqVwTpMYC2bN9l910eciFOwZNV/IgNbeXjuu6sohmtGL29/e7kodObtzS2Ux5qEJ6yphAAHITA6t+ONKDzqFH75VSL1++bOdcciUM8JOs+s3qZ6cPpx4+fCgjqnaaPZVGtXwx6hk6XZVcx2KEqwC/kyKo0rOKmVZdyYOsKNlD4Pltgl09q4uAUlMDZ0uO0ucz95xsbW1ZliXXH3ObAbxbnudZloUqsKU4jtPkGdATzABCLzqIGIdhqJ9a19d7Cr0u9U7qqVnfCm+pZdPu+f2dOI49z0tfD831n9Ixd8NVushUmjyur169Wt39xRKEvfqlLJ0O5CF+vV53zW4tNIYQQkgpHcgDelX1mVgoitn/wVcn2LZtTSv9j2h8O+0hhKwlHciD/Xplq5p9vD4trtQfDMOYKg9Wd/W/CCHrQQfyACdsjTzoKzTRwBWZKg8XFxe4gNRXQsjc9FEePC0tIVf7kGQN5OH58+dyAVtrFSFkzeidPKST1eHBVC/KBjL1shwcHMgFZASCEDIfvZMHr5DRTAOXY6o8YMll6ishZBFakgd9HqAuD2ma6tGFNE2LqeI0cDmmqubOzg71lRCyIG3IA5bTs20bSiDycHZ2hhXhZU/ksxbZcAOHGWGio7lrkpsNXryGDFATQuagpdGDFHiQkiO+729tbelmTk1W9y6yHiXt5kaWq42iSCkl+oql0o3X87uKk3VN0+xPFRdCyFBoSR5QOaeIDCmyCs8SsCxrwzNcRVb1kl5i/adeQw4gCCGz0pI8VI0MdK+RBKVR2xaDBrGG7a/i3SuCIKjSTr2MT9Vutm132HhCyBBpL3OpaLlGo5FeNgP1LFHWPIoiMXxRFKGub2tN7SFV+mqaplxDpRRygvf39/FuHMey6CP9S4SQmWhPHooG7urVq/oOehYTVjyXfvEgit+umtKRgR6VUUph+YfLy0voBLYnSYLyxR01nBAySFqd95BbgeDRo0dVe+qjBwIQoM5RVdcWStxyCwkh60SrFiRn4A4PD6v2pDyUktPXGocb5YEQsiBtW5B79+5J4OF///d/q3ajPJRycXGBleBwAX/66aeqPSkPhJAF6cCCwC1eb/opD1XIrLf6i0N5IIQsSAcWBLk09aFmhGEpD6XURx0A5YEQsiAdWBCsLV6/TxAEtm0z2aYU13UbLgfUTnsIIWtJTy3Ihs+RrkcpNTXN1/f9Da9EQghZkOnyoJQK+wSVgxBCWmC6POSSKTvHHDiu68pMZt/3gyEDtQ6CYMNL6hKylkyXB8dxjo6OlvJlSZLArMRxjPBDmqad2rduKJbVa4Jt2/2Uarzoui0lOI5TXF0KE/Ih0nDB2bbtT8BF9ldGyHAaGQ6tygNZY9I07drvOAMygGsTKFbXN4qQplAeCGkJ13UpD2RAUB4IaQnKAxkW88iD53lOd0RRlNsShmEcx3EcO44Tx/GNGzdc142HD7JXlVL4Fylbce1sONJnKA9kWMwsD1iPDBk4q6MY6jRN0yksk7nemKZp27ZUQbcsCzFtu4ywQcwzTVPHcTzPm7U6ehiGpV9aD7RcsG07iiLXdYMgiAbOfOXlKQ9kWMwpD9GKExkx80sHfed03QmCwPO8JElyW+oxGsc8kftkmmYYhmljGwe1ntoMaYxt28WNOELVcuLDwjRNqwG5K0x5IMNiTnmgi6NXIFm2yZ65muqe5wVBMHWmIQxiw8aUHk0phe2qx6RpmiSJ/BsEwdwJrJDhnDwEQUB5IANiI+RBFQxWcYtsr3qr5lOdA+dPw51LJ094nldzdjPJA8myLI5jygMZOusgD6XuF/HPwF+vFwGEfcz1GXUfSOnZHR8fTy2E1xVhGBqvF+CrcUnVTMrDBLGiTrQsD7kG1Gt28+Ms5ZgNKZUHOpfIsFgHeYjjWA8b7uzsFIOf8kNVSlmWhV8pIqjwhsObnPMJ6FGB/f19eJOFMAw9z+vstDWK8rCIi784EGlZHnIPGG5T1c5xHCNRTbbg7nzwwQdGdU14pD80j77MCuWBrAHrIA85dFNS7CGGYWiaZpIkSZLARsRxbNs2jIXv+7qdjaLI87w4jpE0VZqc09JZ1VKUh5pcoxrlwOihaDTbl4cgCORfBLqrdsZgCDF8vZ4Vtos8KKWSCXEcI9gehqFsxMeXNaSgPJA1YH3kIYoimL+trS3dFOr7YOjg+34URYZhIL0ECZc4KdM0Sy1RmqZXrlzJbenPRSjKQw1eoQyRYRhwx1V9pEN5SJJERnvFaw4rHAQBpN2yrDiOgyCA2Btaih00HliWhTzpIsu6p5QHsgasjzzARCZJ8uzZsziO0R80DEPvD8J3JPMqlFIwFhhSYIhQ9Dmkaeq6rq46GG2g+9n6iZbQXB4ghLnhwtTVmTqRBxneQcgR1zVeT6q2bRvLWuiljZIkMU3zvffecxyndDSAm57buNxcbcoDWQPWSh7gVnrw4AF+hDCFuoGQniMsO3qUcLa4riuR29zZobv98uVLOLVhtoxp2T5t0lweJC5d6kSqojV5kNuBe2TbNpILMKRTSumSDBMsWaSYW44ugmVZu7u7rusWz1ESt3JzFIylzuahPJA1YK3kAY7mBw8e4EVRHrIsQ9cSJkYvr40ZAOiiuto6a2mawlTJFvRhezJuAM3lAUH7WVWtNXlAQhFGD5JcpMceDC0JTU/Bwv4i/xgVyY0WMKCUg8v8BsMwHMeZOopqDuWBrAHrIw/oFWZZdvPmTTSvKA+w9Uh0Qa8TsWj4LjANCm4NfX8YIDmO6MeqkyObI9K4IjqMPSiliqMHNZlCD0nA7YiiSEYSnuf5vu95Xs5V6DhO7kQwNFz680x5IGvA+siDmMh33nkHP8tS5xJsvfQr0e+WElK6hwHa4DgOepdwVuAIlmVJgLcPw4j1kwff91EeCkMEXHDXdSWqjD1xa6T6SBiGcBMFQfD48WNsERsNbcidiD40WWKea6k8eJ5HeSADYn3kAZ3HLMtg0DEZIpeGFMex53lRFCGXMdM80UEQwLLI0CEMQ3ghICH/8R//gQ8ikUZmVLR/pkVmlQfJ42zoTulk9BBFkYQTdEnATMZMC7Mj/Qwbka7muu4//uM/6rYY8o+jRVGkF3/E/tD7Zd3QUnmA5i3l+IS0wPrIQzaZD7W3t4ccx2KQOU1T9OBgU2D3YSil6lzxsDnPPrRh5SczCw3lAbn/ooi2bTd0jrUmD5Bt3B3XdbGyG4Z6xQp38Czp9yKKItxH3/evXr0q1wRpr9nEaovwxHEMsUf5dKmavjh0LpE1YK3kARMXDg8Ps4ntkOwX7ABnBVI5YRrgyIaPoqrzqMsDXOF67LoP1MuDUgpTi3MT4prfxHbkASZVosQoi2KaJk4Nkq8bXNw4mZ+Iux9FEeY9WJZVWmurxrm09HOhPJBBsw7yoJTCnDg9binbDcMoWvMoiqANEAnEHsTNnSvhIPIAC9W3089q5UHc8TlmslPtyINSSp+dh1sjthvCrCsE0grgIsOoCNOekZyWm8YIoDf6FsoDIVWsgzycnZ0dHx+fnZ1dXl4W3y3NLzo5Obm8vHzy5MnR0dHp6anscH5+fnx8fHJykjv+2dkZDnVycvLFF1+UflGHQAP0Ld99993Vq1dHo1FRGMCommKBo+3t7TZjDxcXF3fu3Hny5Mnp6am+fTweHx4eXrt27dtvv8Utw4344Ycf3nvvvU8++SSO44cPHz558uT58+cPHjy4fv3648eP9Zs1Ho/fe+89+ZZr164ZhvHw4cOln0KpPNy5c4fyQAbEOsgDqRo9wM1SKg9YhFU+HkwoDVa3HJpeA1jQm6wBPV0tjsxEfewBnrScPMxk7ov5oKQeOpfIGtDNWtNIFhLEcVyK1NTU8xH1WptC6cY+s6y7iBXK6vdBrTpdJ5prPGYgL9zMDYLyQNaAmeUhm8zuWTViyOrfHTRIuVkco3phgxzIYnIcpyq3pxRc7ebtwbwTHcw5wN/h8t///d9NLlc2SWegPJBBM488tIMU6C99F6Xx1oNYqzWNpFsAV7X+VhiGVRZ5VncfpgIkzUYwuZYsQseCvBiI2zcBIR9OiyODpr/yQNaSdE2RJWx1D2ru3FlUgwwLygMhLUHnEhkWjeRhd3c36A0xc2rJMKE8kGExXR6CIDBXTNcu5fbwfV9fpUDfDlAQCZU/hgIiJVXvpmmqhsnSf2yUBzIsmi5QvFKiKAo3hiAIrNaBBiNbqbWvGzruZAHBZWFNFs0mZBD0Qh7IqkmSxNBqlbfwddHwcRxH6v1FUYSqXAuyivpOhKyINZcHpVTDWEW6vKVgekiapo7jrPc5EkKWy5rLAxz90bQ5AUmSOI6zCnczIYQMlDWXBzjBg0IGeg739WVECSGEUB7+7pc3DKNYyJoQQjaWjZCH+n3cyeKaHEAQQoiw6fKQpqmey8jEEkIIARshDzXJS2EY5rLd22weIYT0ljW3hvWxB6WUVSgMTv8SIYRkaykPf/7zn8XE6/KAspp67n9x6GAYhvX6os2EELKZrKE8PHnyBIvZRVEk8hCGIV7rM4f1oDQHEIQQorOG8vD8+fOcuZcSQLnU1VJt4ACCEEKytZSHi4uLKruvDwuCIKjazSis80UIIZvGGspDacAZYwjd6GNhS9d1UVEDfieZIscMV0LIhrOG8pBpE6F1cp6lMAwlDgF5EPEIgsD3/bYbTQghfWI95aF0AFEz+yEnD4QQQtZTHrJCVlJ9tJnyQAghOdZWHnL+pXpnEeWBEEJyrK08ZFn29ddfQxuuXbtWv5YD5YEQQnKsszxkDWouAcoDIYTkWHN5QNLq1N0oD4TUEIah7/u+78sMU8Tz/AlcaXEtWXN5aEgURUEQ8BEnBCilfN/HWrwybQgEQRAEgeM4pobs43meXreGDJpG8pCugOLBV3aOhJBGpGkqqmCapm3bYRiGYTjVPRtFURiGrusiodxxnCAI+KMeOtPlwff9muITc+NOKG5ZGzANO4oi3/fxOggCvIVOVhAE8ndxVvqgJEkioyv5LnwvR13rAXxHGAFEUTSfcVdKRVEEby1+1Hw8hst0eXAc57e//W2sEQQBXoRhiG5CHMd4JtYbdItAad2OblldoVl0EWzblutg27Z4HmR7D5FnFch213XjLuin4yVJEtxN9GmWdUzXdfF4UCEGSiN5ODo6aqEp/UfvTymlltLlXwow31WrHi0OZKC7Ydg8vPnmm52IdD1Og0SJlknTFMGDKIqWbseTJLEsy7KseJp7ivQQysM6oJQyViwPpmmu6OArQim1ipjZImDg0vWFyeO6rrHKoWeappZlcQwxRCgPawLlof8g4afrVrwGFkxc3ZMDkiQxDMN13ZV+C1k6lIc1gfLQf1zX7Zs8wK3UwhcFQWBZFgcQw4LysCY0lIcgCOZwMVMeloLrun0zkaZptlO7HgOIpJeReVIF5WFNaCgPSFCxbdvzvLRx5iLlYSmsYvQQhmGapnNLDtJYl9ukUuI4pjwMDsrDmtBQHvArFTD9YqpxoTwshVXIA7xDtm3Pl3eEj7cwoEG/hPIwLCgPa0Lz2ENxniOMS81ggvKwFFYhD2ma6vdxpkFhpqnLcluVQzollIdhQXlYE3LyEMdxVIH7+kJJAvwMpcaF8rAUVhSazt1QmfZ8eXk59bNSLsn3/Zl0pTlxHMu3UB6GBeVhTcjJw9yTuk3TLJowysNSqJEH1CyaD2dSwSLHe++9N7VJ0BKJSC1dIcIwlEJ+lIfBMTx5sG1bn4Hpum7VjBu9lFgcx8EE13VrJgEFQRCG4SIt7OQ3kJOHIAj8CqqsCXDLiuRQHpZCUl1eXq+NukRM06yfbYDMJaWU53nYf1nVuVGhD8dMkgST4ygPw2Jg8hBFkfH6yqA1M1Hxk8Ozjqff8zx5UfoRpN+ZpqmUwrRb3/eLWiIlLYvgZ7mk050Bo3HsAf24oh2pSXBsLg/6zC9cPdGkqtt0fHxsmubUfqvYrPmMF0qP1OyADkTp8Uu/ESWvZ+pJ1IwewjAM5sJxnCpp2dramlo2Vb/vIhKGYaATNselVkphxIDjyDPJxNYhMjB5yLLMsizdDup2J/c0Q0swgMAIWo5QJQ/OpO4ehu1w0RR3Rgyw9AiYhjrXmS1EQ3lIXl+CG9Zhaj2c5vKA48NoIiAJG+o4TtURnj59imvueR6WnSleW9wLmFeReYD9Pc/TNQZPAjQeW/AwFO1dHMfiXREfCJ4xYNu2ZVmyv5qQpqlt2+gaZ5MaHvUKtKLYg9h0/bZalnV2djb1s8VuQZqmuJg4FO6LZLhVgX3wexFvkn7YenmQS+p5HmQpR1VRcXz1iqImZGDygIcsjuM0TVF5Dc+i7/vwMuX2l46//i4MDcrg6DuLacDoIUkSOOKLNgUmo7QSHAzNas6+jobyIGFMLPXV8HfVXB6yLLMsC5cd8oCvCIKg6gj7+/v4SBRFNWM7z/NgKXCm6DVHUZQkiUTdsSeqG8GLKMXgauQBb8EJk6apaZr6mABfhNfn5+e4dLjRjuNYlgUDiscGV7Xqyqwoc0mPM6FtzTvpNaNG3A4U1CsdnRQFyXGcqvzaenkIgmA0GuG75EshUbIl93gjWoM0PEz+SNM0DMPVFY/aQIYkD7JQifws4zhGZWn0O8QuoyeCaqZ4oVtP3fkuz2sURTJFCAuhQHhKDShMQ2nFZjj9W7ker9FcHpoMF4oHnyP2gEuqywPuiG4+0jS9fv06jLhSqmqQoZTCoZRS6MtjT7l9QRDoopK7a0opaD9Kaheneui9Xdu2dSume5AgD1XFeqdWnVuFPOh6H4bhrO6ghrOmkySRJ/ztt98uPvZT+xlTnUv7+/vyGjdaV/TiB1GlA8+YbdsQ7Hp5JrMyJHnAM4pom5TOF+eS7tXB2EJK2OMB0p3XcB/lrIA8WDIzoMqzLM4lvY6/UiqOY8dx+hCaXvrBp8oDTh+CDZe3PiMXP3VjEqjERvR8T09PsRANOoylV09uri4Phhb2rDr9JEnCMBT3EZ4WGaCgzTJqxG01DAOrpOF08PDgaCIPuVUlxPvfvnNJ1rSYLyTTn6Iav/nNb/ACT45cVVlZJNenkQ6B3guxbZvysESGJA/Asiy9q1IqD0CcBuKLgGaIpSg9Phyv8EtgSFvqXEKHUXxKcILjdSfD2z7IA2wxftKwthi6ZVkGTz18evKROI4hwCIeUyM66DNmk/sOXUEPQG5TGIYY3unNkK4o3FO4R2izLHaE9sO5BLBcgVzY8/NziUMopfAtaFIQBFO7Bf0sydcTecDoByFx3CDJhYWbF/cXCVG477hrGD/hYTAma6A6jsOAxOIMUh5c18WvV5Jw4GhGH/Dw8BB75ganeObSNMWnikY8iiK4WeFPgEkyJtmBL168kD3h9a5qIR7oFZx6HbPKA7RtFbEHYzJ9V8Zt+D3j7hT3Pz091fv1uLm5fUQeYBewNCFycPGp3Lkrpa5cuQI/OB6AUnnQD47DYvyH5GaZVSCidX5+rl8HmK1ix7YKykPV7yKKou3tbXh05XZI7AFgTzVZxgMPDHx6EnvA81YMK5L5GKQ8oIsBlw4sOCyFgD1z0UgYKVmcRA6I5AdJ1YA8yGvxG+zt7WF/qRAgUXE4RmRSBba3fFkaygNUQX54zQ8+kzyIfcdPN5tYh2ILgyDY2dmB6x/okqwfBxsNDQST8ZFidv9bb72lG6MoinDTi/KAPoG4IvXZIXitjx6gZLk8ZkggttcUqFhEHmTYtFx6Ig+2be/u7vq+j7kRUFzoBEZ+xXM3TROqrF/V1k5nQxiYPMD1jMEjXAEYk0q2jA7kAY5p8XsAfWfELZE8J+5jyXQqZrzoCTmZ5hjpdrnEenlQr2ej13tySg8+hzzAs48S1sWYs8ynHY1GsH24+LpClP7UJRgLSYCfOmd6XNc9OjqCucG9k3BRTh7kqYBvMHdbc37Fs7Oz3EXTHwb0Kmqu6hzygJl0+vkulz7IA+JV165d0+VBkpgRTsjlFutXEr9f/T62cDobwmDkIZ2siIt+pczDxFMCL7Mqm/egd2bxwFXV3JdRrfwgJZVb319UB//iq/GvPnZpmSp5QJTeKDBTV3RWeUBqGQLUcAYa1XH+vb09iQ0gB6Z4LjK5QUyGZK9hT/34iCf/9a9/haFBUAG+o6wgD7A+euYSYp76BAuxOE+fPq2Rh1yyQ5Hm8pAkSW5EW9P1XoQ+yAO4fv06ZAAPAO44ngTMPpHjoFcBhxIyCOAxlhhSC6ezIQxGHuACkqzq3AK2EI9c1FrPZ1dKifsbG4vZjZAHDAJgfXLZdUAcJuiS61+qS0XL5Ewq2lZVfc+Y+ENKKdqLWeVB78TJaKBKOCXh3Zg4mo1CeUEkvyN0BCObU3q8i/3hJtra2tIPK/NXdHmQwY3IA+44Uv5hg/QZFU+fPs2NEXNDyXqmykPNXVvRqgz9kYd3331XRglQ5dLLBZcyfqoYgEr/A0+v0cWso3VlMPIg/Pzzzx9++OGDBw+Ojo50i3N6erq3t7ezs/Pv//7v2KKUevbs2eeff37nzp0HDx4cHh6en58rpU5PTw8ODq5cufL++++/evVKjvDs2bOtra27d+8+efLkwYMH9+/ff/Lkye9+97udnR2xLA8fPrxz5w5qYTqOs7OzY9v23t7ekydPnjx5cv/+/f39/a2trXYvSZYV5GE8HuMct7a2qhRip4J33303d/Ctra3m8nBwcHBwcPCXv/zl0aNHv/vd73DlDw4ObNve398/ODg4PT3V9/+Hf/iH4+Pju3fvGobx5ZdfHh4eFkcPWZZdXFwcHx/fv39/Z2fn5cuX0O/j4+PxeHxycnJ4ePj48WPMEz4+Pj4+Pv6///u/LMt+/vnnN954A7fs/Pz88PDw0aNHb731Fm4oPp5p8x7GE/7lX/7lypUr5+fn+NTZ2ZlS6p/+6Z/0R248Hn/22WdvvPFGk9qoWZa5rvv222+XyuTPP/+MJ6f+ZuEJB7u7u/q/V69ePShw8+bNTz/9tKZJ/ZGHX/3qV3fv3v3Nb36jlHrx4oVpmltbW++88875+Xnx8kqqglRDQEQafZGVnshGMTx5WClTXUNNfEd9GD0I8MwWJ77OFDyfKdiOMhW+7xdtAWY4567hJ598kptohnktxSOjGjneECEFugAAAqRJREFUgs8hNzGtOA0esxfxr5rUFCoeHPKAoQMOhVAEkpeQrJym6cnJif4pjEebhwTQty01kfjqmsJ8VUO9qdS7pPojD999912mpU5gJocUCsQQIZuMHrAdjibEHaWKAUYVq6g+u4FQHtaEKnkAMmVPtzjN52fMKic9oVTLqzbOFzRqMt1BqJEHaYbM/98051KWZXEcI1VMvxcQTtRiyialiOF9wvZSGKBeCpSHNaFeHgSZBWbMEsQbqDz0janyIEhYS1eI9Q5Nkx5CeVgTGsqDgJ5aw2RczFeat2nk77iuW5U1VwX86UhhWtfEVtJbKA9rwqzyMOvBKQ+Ls8i0OFSOWm57MsoDqYXysCZQHvrPIvKwIigPpIZG8nBwcFBVwlevL1RT4FfKeUoxjFWczCazUnlALdUVHXxzoDzwhz8sGslDaaYdystIkDOXk4d3hWJipb0BBEGASVVYkbT4elkg2rw6eUBJjOL3dltHZHD0UB5kovKqvyi3nB8ZBNPlIZ0d5KcTwV7NQvM5Vmes9RqFOaxhgnXNkBmJREk8tPpbywVTfPsmD5j1ba2g2J9OFEUsljdEOMOwJdTqWWnj0zR99eoVvkgSzweHbdvFF1gZwvM8aINbXYlkcfomD9mk9szqbDcUiEOHIUJ5ICTPECV8EaQc2dItOKpcVC0CSHoO5YEQ8nf/j2EYbuNFompQ2iz9VagOaQfKAyEkyyZVjWWpqCiK0jSddcSjz+MztcXGyRChPBBC/j8QCVtLSnRdN5pUKsz5iLCWOCpsu5MFfJC1OHX1C9J/KA+EkBJQdgVLa+gLEzkash1RfcdxqArrBOWBEDIFGSVU0duoO1kEygMhhJASKA+EEEJKoDwQQggpgfJACCGkBMoDIYSQEigPhBBCSvh/dzNhg2hBvlwAAAAASUVORK5CYII=" alt="" />

VFS的任务很复杂，它起到承上启下的作用

. 一方面，它用来向用户态提供一种操作文件、目录及其他对象的统一方法

. 另一方面，它必须能够与各种方法给出的具体文件系统的底层实现进行兼容

这导致了VFS在实现上的复杂性。但VFS带来的好处是使得Linux内核更加灵活了，Linux内核支持很多种文件系统

. ext2

是Linux使用的，性能很好的文件系统，用于固定文件系统和可活动文件系统。它是作为ext文件系统的扩展而设计的。ext2在Linux所支持的文件系统中,提供最好的性能(在速度和CPU使用方面)，ext2是Linux目前的主要文件系统 

. ext3文件系统

是对ext2增加日志功能后的扩展。它向前、向后兼容ext2。意为ext2不用丢失数据和格式化就可以转换为ext3，ext3也可以转换为ext2而不用丢失数据(只要重新安装该分区就行了) 

. proc

是一种假的文件系统，用于和内核数据结构接口，它不占用磁盘空间。参考 man proc 

. Devpts

是一个虚拟的文件系统，一般安装在/dev/pts。为了得到一个虚拟终端，进程打开/dev/ptmx，然后就可使用虚拟终端 

. raiserfs

是Linux内核2..1以后(2001年1 月)支持的，一种全新的日志文件系统 

. swap文件系统

swap文件系统用于Linux的交换分区。在Linux中，使用整个交换分区来提供虚拟内存，其分区大小一般应是系统物理内存的2倍，在安装Linux 操作系统时，就应创分交换分区，它是Linux正常运行所必需的，其类型必须是swap,交换分区由操作系统自行管理

. vfat文件系统

vfat是Linux对DOS、Windows系统下的FAT(包括fat16和Fat32)文件系统的一个统称 

. NFS文件系统

NFS即网络文件系统，用于在UNIX系统间通过网络进行文件共享，用户可将网络中NFS服务器提供的共享目录挂载到本地的文件目录中，从而实现操作和访问NFS文件系统中的内容

. ISO 9660文件系统

文件系统中光盘所使用的标准文件系统，是一种针对ISO9660标准的CD-ROM文件系统，Linux对该文件系统也有很好的支持，不仅能读取光盘和光盘ISO映像文件，而且还支持在Linux环境中刻录光盘

0x1: 文件系统类型

文件系统一般可以分为以下几种

. 基于磁盘的文件系统(Disk-based Filesystem)

是在非易失介质存储文件的经典方式，用以在多次会话之间保持文件的内容。实际上，大多数文件系统都由此演变而来，例如

    ) Ext2/

    ) Reiserfs

    ) FAT

    ) ISO9660

所有这些文件系统都使用面向块的介质，必须解决以下问题: 如何将文件内容和结构信息存储在目录层次结构上 

. 虚拟文件系统(Virtual Filesystem)

在内核中生成，是一种使用户应用程序与内核通信的方法。proc文件系统就是这一类的最好示例，它不需要任何种类的硬件设备上分配存储空间，而是内核建立了一个层次化的文件结构，其中的项包含了与系统特定部分相关的信息

ll /proc/version

/*

占用空间: 0字节

-r--r--r--. 1 root root 0 Feb 27 23:39 /proc/version

*/

cat /proc/version

/*

从内核内存中的数据结构提取出来

Linux version 2.6.32-504.el6.x86_64 (mockbuild@c6b9.bsys.dev.centos.org) (gcc version 4.4.7 20120313 (Red Hat 4.4.7-11) (GCC) ) #1 SMP Wed Oct 15 04:27:16 UTC 2014

*/

. 网络文件系统(Network Filesystem)

基于磁盘的文件系统和虚拟文件系统之间的折中。这种文件系统允许访问另一台计算机上的数据，该计算机通过网络连接到本地计算机。它仍然需要文件长度、文件在目录层次中的位置、文件的其他重要信息。它也必须提供函数，使得用户进程能够执行通常的文件相关操作，如打开、读、删除等。由于VFS抽象层的存在，用户空间进程不会看到本地文件系统和网络文件系统之间的区别

2. 通用文件模型

VFS不仅为文件系统提供了方法和抽象，还支持文件系统中对象(或文件)的统一视图。由于各个文件系统的底层实现不同，文件在不同的底层文件系统环境下特性存在微秒的差异

. 并非所有文件系统都支持同样的功能，而有些操作对"普通"文件是不可缺少的，却对某些对象完全没有意义，例如集成到VFS中的命名管道

. 并非每一种文件系统都支持VFS中的所有抽象，例如设备文件无法存储在源自其他系统的文件系统中(例如FAT)，因为FAT的设计没有考虑到设备文件这类对象

VFS的设计思想是提供一种结构模型，包含一个强大文件系统所应具备的所有组件，但该模型只存在于虚拟中，必须使用各种对象和函数指针与每种文件系统适配。所有文件系统的实现都必须提供与VFS定义的结构配合的例程，以弥合两种视图之间的差异(由底层的文件系统实现这个向上适配工作)
需要明白的是，虚拟文件系统的结构并非是凭空创造出来的，而是基于描述经典文件系统所使用的结构。VFS抽象层的组织和Ext2文件系统类似，这对基于完全不同概念的文件系统(例如ReiserFS、XFS)来说，会更加困难，但处理Ext2文件系统时会提高性能，因为在Ext2和VFS结构之间转换，几乎不会损失时间
另一方面来说，在处理文件时，内核空间和用户空间所使用的主要对象是不同的

. 对用户程序来说

一个文件由一个"文件描述符"标识，文件描述符是一个整数，在所有有关文件的操作中用作标识文件的参数。文件描述符是在打开文件时由内核分配的，只在一个进程内部有效，两个进程可以使用同样的文件描述符，但二者并不指向同一个文件，基于同一个描述符来共享文件是不可能的

. 对内核来说

内核处理文件的关键是inode，每个文件(目录)都有且只有一个对应的inode，其中包含元数据(如访问权限、上次修改时间、等等)和指向文件数据的指针。但inode并不包含文件名

关于Linux下inode、链接的相关知识，请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/4208619.html

0x1: 编程接口

用户进程和内核的VFS实现之间由"系统调用"组成，其中大多数涉及对文件、目录和一般意义上的文件系统的操作，和文件操作相关的系统调用请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/3850653.html

//搜索：0x3: 系统调用分类

文件使用之前，必须用open或openat系统调用打开，在成功打开文件之后，内核向用户层返回一个非负的整数，这种分配的文件描述符起始于3(0表示标准输入、1表示标准输出、2表示标准错误输出)。在文件已经打开后，其名称就没有用处了(文件名只是在利用inode进行文件遍历的时候起过滤作用)，它现在由文件描述符唯一标识，所有其他库函数都需要传递文件描述符作为一个参数(进一步传递到系统调用)
尽管传统上文件描述符在内核中足以标识一个文件，但是由于多个命名空间(namespace)和容器(container)的引入，在不同层次命名空间中看到的同一个进程中的文件描述符(fd)是不同的，因为对文件的唯一表示由一个特殊的数据结构(struct file)提供
系统调用read需要将文件描述符作为第一个参数，以标识读取数据的来源
在一个打开文件中的当前位置保存在"文件位置指针(f_pos)"，这是一个整数，指定了当前位置与文件起始点的偏移量。对随机存取文件而言，该指针可以设置成任何值，只要不超出文件存储容量范围即可，这用于支持对文件数据的随机访问。其他文件类型，如命名管道或字符设备的设备文件，不支持这种做法，它们只能从头至尾顺序读取
系统调用close关闭与文件的"连接"(释放文件描述符，以便在后续打开其他文件时使用)
关于struct file数据结构的相关知识，请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/3865490.html

//搜索：0x1: struct file

0x2: 将文件作为通用接口(万物皆文件)

*nix似乎基于少量审慎选择的范型而建立的，一个非常重要的隐喻贯穿内核的始终(特别是VFS)，尤其是在有关输入和输出机制的实现方面
大多数内核导出、用户程序使用的函数都可以通过(VFS)定义的文件接口访问，以下是使用文件作为其主要通信手段的一部分内核子系统

. 字符和块设备

. 进程之间的管道

. 用于所有网络协议的套接字

. 用户交互式输入和输出的终端

要注意的是，上述的某些对象不一定联系到文件系统中的某个项。例如，管道是通过特殊的系统调用生成，然后由内核中VFS的数据结构中管理，管道并不对应于一个可以用通常的rm、ls等命令访问的真正的文件系统项

3. VFS相关数据结构

0x1: 结构概观

VFS由两个部分组成: 文件、文件系统，这些都需要管理和抽象

. 文件的表示

inode是内核选择用于表示文件内容和相关元数据的方法，理论上，实现这个概念只需要一个大的数据结构，其中包含了所有必要的数据，但实际上，linux内核将数据结构分散到一些列较小的、布局清晰的结构中

在抽象对底层文件系统的访问时，并未使用固定的函数，而是使用了函数指针。这些函数指针保存在两个结构中，包括了所有相关的函数，因为实际数据是通过具体文件系统的实现操作的，调用接口总是保持不变，但实际的工作是由特定于实现的函数完成的

    ) inode操作: "struct inode"->"const struct inode_operations *i_op"

    特定于inode操作有关，负责管理结构性的操作，例如创建链接、文件重命名、在目录中生成新文件、删除文件

    ) 文件操作: "struct file"->"const struct file_operations *f_op;"

    特定于文件的数据内容的操作，它们包含一些常用的操作(如读和写)、设置文件位置指针、创建内存映射等操作

除此之外，还需要其他结构来保存与inode相关的信息，特别重要的是与每个inode关联的数据段，其中存储了文件的内容或目录项表。每个inode还包含了一个指向底层文件系统的超级快对象的指针(struct super_block *i_sb;)，用于执行对inode本身的操作(这些操作也是通过函数指针数组实现的)

因为打开的文件总是分配到系统中的一个特定的进程，内核必须在数据结构中存储文件和进程之间的关联，我们知道，task_struct包含了一个成员，保存了所有打开的文件的一个数组

各个文件系统的实现也能在VFS inode中存储自身的数据(不通过VFS层操作)

/*

http://www.cnblogs.com/LittleHann/p/3865490.html

搜索：0x2: struct inode

搜索：0x1: struct file

*/

. 文件系统和超级块信息

VFS支持的文件系统类型通过一种特殊的内核对象连接进来，该对象提供了一种读取"超级块"的方法，除了文件系统的关键信息(块长度、最大文件长度、..)，超级块还包含了读、写、操作inode的函数指针

内核还建立了一个链表，包含所有"活动"(active、或者称为"已装载(mounted)")文件系统的超级块实例

超级块结构的一个重要成员是一个列表，包括相关文件系统中所有修改过的inode(脏inode)，根据该列表很容易标识已经修改过的文件和目录，以便将其写回到存储介质，回写必须经过协调，保证在一定程度上最小化开销

    ) 因为这是一个非常费时的操作，硬盘、软盘驱动器及其他介质与系统其余组件相比，速度慢了几个数量级

    ) 另一方面，如果写回修改数据的间隔时间太长也可能带来严重后果，因为系统崩溃(停电)会导致不能恢复的数据丢失

内核会周期性扫描脏块(dirty inode)的列表，并将修改传输(同步)到底层硬件

/*

http://www.cnblogs.com/LittleHann/p/3865490.html

搜索：0x10: struct super_block

*/

值得注意的，inode和file结构体都包含了file_operations结构的指针，而inode还额外包含inode_operations结构指针

0x2: 特定于进程的信息

文件描述符(fd)用于在一个进程内唯一地标识打开的文件，这使得内核能够在用户进程中的描述符和内核内部使用的结构之间，建立一种关联

struct task_struct

{

    ...

    /*

    文件系统信息，整数成员link_count、total_link_count用于在查找环形链表时防止无限循环

    */

    int link_count, total_link_count; 

    //用来表示进程与文件系统的联系，包括当前目录和根目录、以及chroot有关的信息

    struct fs_struct *fs; 

    //表示进程当前打开的文件

    struct files_struct *files;

    //命名空间

    strcut nsproxy *nsproxy;

    ...

}

由于命名空间、容器的引入，从容器(container)角度看似"全局"的每个资源，都由内核包装起来，分别由每个容器进行管理，表现出一种虚拟的分组独立的概念。虚拟文件系统(VFS)同样也受此影响，因为各个容器可能装载点的不同导致不同的目录层次结构(即在不同命名空间中看到的目录结构不同)，对应的信息包含在ns_proxy->mnt_namespacez中
关于命名空间的相关知识，请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/4026781.html

//搜索：2. Linux命名空间

0x3: 文件操作

文件不能只存储信息，必须容许操作其中的信息。从用户的角度来看，文件操作由标准库的函数执行。这些函数指示内核执行体统调用(VFS提供的系统调用)，然后VFS系统调用执行所需的操作，当然各个文件系统实现的接口可能不同，因而VFS层提供了抽象的操作，以便将通用文件对象与具体文件系统实现的底层机制关联起来
用于抽象文件操作的结构必须尽可能通用，以考虑到各种各样的目标文件。同时，它不能带有过多只适用于特定文件类型的专门操作。尽管如此，仍然必须满足各种文件(普通文件、设备文件、..)的特殊需求，以便充分利用。可见，VFS的数据机构是一个承上启下的关键层

各个file实例都包含一个指向struct file_operation实例的指针，该结构保存了指向所有可能文件操作的函数指针
如果一个对象使用这里给出的结构作为接口，那么并不必实现所有的操作，例如进程间管道只提供了少量的操作，因为剩余的操作根本没有意义，例如无法对管道读取目录内容，因此readdir对于管道文件是不可用的。有两种方法可以指定某个方法不可用

. 将函数指针设置为NULL

. 将函数指针指向一个占位函数，该函数直接返回错误值

0x4: VFS命名空间

我们知道，内核提供了实现容器的底层机制，单一的系统可以提供很多容器，但容器中的进程无法感知容器外部的情况，也无法得知所在容器有关的信息，容器彼此完全独立，从VFS的角度来看，这意味着需要针对每个容器分别跟踪装载的文件系统，单一的全局视图是不够的
VFS命名空间是所有已经装载的、构成某个容器目录树的文件系统的集合
通常调用fork、clone建立的进程会继承其父进程的命名空间(即默认情况，新进程和父进程会存在于同一个命名空间中)，但可以设置CLONE_NEWNS标志，以建立一个新的VFS命名空间

关于VFS命名空间的相关知识，请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/3865490.html

//搜索：0x3: struct nsproxy

命名空间操作(mount、umount)并不作用于内核的全局数据结构，而是操作当前命名空间的实例，可以通过task_strcut的同名成员访问，改变会影响命名空间的所有成员，因为一个命名空间中的所有进程共享同一个命名空间实例

0x5: 目录项缓存: dentry缓存

我们知道，若干dentry描绘了一个树型的目录结构(dentry树)，这就是用户所看到的目录结构，每个dentry指向一个索引节点(inode)结构。然而，这些dentry结构并不是常驻内存的，因为整个目录结构可能会非常大，以致于内存根本装不下。Linux的处理方式为

. 初始状态下: 系统中只有代表根目录的dentry和它所指向的inode

. 当要打开一个文件: 文件路径中对应的节点都是不存在的，根目录的dentry无法找到需要的子节点(它现在还没有子节点)，这时候就要通过inode->i_op中的lookup方法来寻找需要的inode的子节点，找到以后(此时inode已被载入内存)，再创建一个dentry与之关联上

由这一过程可见，其实是先有inode再有dentry。inode本身是存在于文件系统的存储介质上的，而dentry则是在内存中生成的。dentry的存在加速了对inode的查询
每个dentry对象都属于下列几种状态之一

. 未使用(unused)状态

该dentry对象的引用计数d_count的值为0，但其d_inode指针仍然指向相关的的索引节点。该目录项仍然包含有效的信息，只是当前没有人引用他。这种dentry对象在回收内存时可能会被释放 

. 正在使用(inuse)状态

处于该状态下的dentry对象的引用计数d_count大于0，且其d_inode指向相关的inode对象。这种dentry对象不能被释放 

. 负(negative)状态

与目录项(dentry)相关的inode对象不复存在(相应的磁盘索引节点可能已经被删除)，dentry对象的d_inode指针为NULL。但这种dentry对象仍然保存在dcache中，以便后续对同一文件名的查找能够快速完成。这种dentry对象在回收内存时将首先被释放

为了提高目录项对象的处理效率，加速对重复的路径的访问，引入dentry cache(简称dcache)，即目录项高速缓。它主要由两个数据结构组成：

. 哈希链表(dentry_hashtable):

内存中所有活动的dentry实例在保存在一个散列表中，该散列表使用fs/dcache.c中的全局变量dentry_hashtable实现，dcache中的所有dentry对象都通过d_hash指针域链到相应的dentry哈希链表中。d_hash是一种溢出链，用于解决散列碰撞

. 未使用的dentry对象链表(dentry_unused):

内核中还有另一个dentry链表，表头是全局变量dentry_unused(在fs/dcache.c中初始化)

dcache中所有处于unused状态和negative状态的dentry对象都通过其d_lru指针域链入dentry_unused链表(super_block->s_dentry_lru)中。该链表也称为LRU链表

为了保证内存的充分利用，在内存中生成的dentry将在无人使用时被释放。d_count字段记录了dentry的引用计数，引用为0时，dentry将被释放。

这里的释放dentry并不是直接销毁并回收，而是将dentry放入目录项高速缓的LRU链表中(即dentry_unused指向的链表中)。当队列过大，或系统内存紧缺时，最近最少使用的一些dentry才真正被释放

目录项高速缓存dcache是索引节点缓存icache(inode cache)的主控器(master)，即dcache中的dentry对象控制着icache中的inode对象的生命期转换。无论何时，只要一个目录项对象存在于dcache中(非negative状态)，则相应的inode就将总是存在，因为inode的引用计数i_count总是大于0。当dcache中的一个dentry被释放时，针对相应inode对象的iput()方法就会被调用
当寻找一个文件路径时，对于其中经历的每一个节点，有三种情况:

. 对应的dentry引用计数尚未减为0，它们还在dentry树中，直接使用即可

. 如果对应的dentry不在dentry树中，则试图从LRU队列去寻找。LRU队列中的dentry同时被散列到一个散列表中，以便查找。查找到需要的dentry后，这个dentry被从LRU队列中拿出来，重新添加到dentry树中

. 如果对应的dentry在LRU队列中也找不到，则只好去文件系统的存储介质里面查找inode了。找到以后dentry被创建，并添加以dentry树中

dentry结构不仅使得易于处理文件系统，对提高系统性能也很关键，它们通过最小化与底层文件系统实现的通信，加速了VFS的处理。每个由VFS发送到底层实现的请求，都会导致创建一个新的dentry对象，以保存请求的结果，这些对象保存在一个缓存中，在下一次需要时可以更快速地访问，这样操作就能够更快速地执行

0x6: dentry管理

关于struct dentry结构的相关知识，请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/3865490.html

//搜索：0x7: struct dentry

各个dentry实例组成了一个网络(层次目录网络)，与文件系统的结构形成一定的映射关系。在内核中需要获取有关文件的信息时，使用dentry对象很方便，dentry更多地体现了linux目录组织关系，但它不是表示文件及文件内容，这一职责分配给了inode，使用dentry对象很容易找到inode实例

Linux File System

Relevant Link:

http://blog.csdn.net/denzilxu/article/details/9188003

http://www.cnblogs.com/hzl6255/archive/2012/12/31/2840854.html

4. 处理VFS对象

0x1: 文件系统操作

尽管"文件操作"对所有应用程序来说都属于标准功能，但"文件系统操作"只限于少量几个系统程序，即用于装载和卸载文件系统的mount、unmount程序。同时还必须考虑到另一个重要的方面，即文件文件在内核中是以模块化形式实现的，这意味着可以将文件系统编译到内核中，而内核自身在编译时也完全可以限制不支持某个特定的文件系统。因此，每个文件系统在使用以前必须注册到内核，这样内核能够了解可用的文件系统，并按需调用装载功能(mount)

1. 注册文件系统

在文件系统注册到内核时，文件系统是编译为模块(LKM)，或者持久编译到内核中，都没有差别。如果不考虑注册的时间(持久编译到内核的文件系统在启动时注册，模块化文件系统在相关模块载入内核时注册)，在两种情况下所用的技术是同样的
\linux-2.6.32.63\fs\filesystems.c

/**

 *    register_filesystem - register a new filesystem

 *    @fs: the file system structure

 *

 *    Adds the file system passed to the list of file systems the kernel

 *    is aware of for mount and other syscalls. Returns 0 on success,

 *    or a negative errno code on an error.

 *

 *    The &struct file_system_type that is passed is linked into the kernel

 *    structures and must not be freed until the file system has been

 *    unregistered.

 */

int register_filesystem(struct file_system_type * fs)

{

    int res = ;

    struct file_system_type ** p;

    BUG_ON(strchr(fs->name, '.'));

    if (fs->next)

        return -EBUSY;

    //所有文件系统都保存在一个单链表中，各个文件系统的名称存储为字符串

    INIT_LIST_HEAD(&fs->fs_supers);

    write_lock(&file_systems_lock);

    /*

    在新的文件系统注册到内核时，将逐元素扫描该单链表

    1. 到达链表尾部: 将描述新文件系统的对象置于链表末尾，完成了向内核的注册

    2. 找到对应的文件系统: 返回一个适当的错误信息，表明一个文件系统不能被注册两次

    */

    p = find_filesystem(fs->name, strlen(fs->name));

    if (*p)

        res = -EBUSY;

    else

        *p = fs;

    write_unlock(&file_systems_lock);

    return res;

}

EXPORT_SYMBOL(register_filesystem);

关于"struct file_system_type"的相关知识，请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/3865490.html

//搜索：0x11: struct file_system_type

2. 装载和卸载

目录树的装载和卸载比仅仅注册文件系统要复杂得多，因为后者(注册文件系统)只需要向一个链表添加对象，而前者(目录树的装载和卸载)需要对内核的内部数据结构执行很多操作，所以要复杂得多。文件系统的装载由mount系统调用发起，在详细讨论各个步骤之前，我们需要阐明在现存目录树中装载新的文件系统必须执行的任务，我们还需要讨论用于描述装载点的数据结构
vfsmount结构

unix采用了一种单一的文件系统层次结构，新的文件系统可以集成到其中

aaarticlea/png;base64,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" alt="" />

使用mount指令可查询目录树中各种文件系统的装载情况

在这里例子中，/mnt和/cdrom目录被称为"装载点"，因为这是附接(装载)文件系统的位置。每个装载的文件系统都有一个"本地根目录"，其中包含了系统目录(例如对于cdrom这个装载点来说，它的系统目录就是src、libs)。在将文件系统装载到一个目录时，装载点的内容被替换为即将装载的文件系统的相对根目录的内容，前一个目录数据消失，直至新文件系统卸载才重新出现(在此期间旧文件系统的数据不会被改变，但是无法访问)
从这个例子中可以看到，装载是可以嵌套的，光盘装载在/mnt/cdrom目录中，这意味着ISO9660文件系统的相对根目录装载在一个reiser文件系统内部，因而与用作全局根目录的ext2文件系统是完全分离的
在内核其他部分常见的父子关系，也可以用于更好地描述两个文件系统之间的关系

. ext2是/mnt中的reiserfs的父文件系统

. /mnt/cdrom中包含的是/mnt的子文件系统，与根文件系统ext2

每个装载的文件系统都对应于一个vfsmount结构的实例，关于结构体定义的相关知识，请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/3865490.html

//搜索：0x8: struct vfsmount

超级块管理

在装载新的文件系统时，vfsmount并不是唯一需要在内存中创建的结构，装载操作开始于超级块的读取。file_system_type对象中保存的read_super函数指针返回一个类型为super_block的对象，用于在内存中表示一个超级块，它是借助底层实现产生的
关于struct super_block的相关知识，请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/3865490.html

搜索：0x10: struct super_block

mount系统调用

mount系统调用的入口点是sys_mount函数，\linux-2.6.32.63\fs\namespace.c

SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name, char __user *, type, unsigned long, flags, void __user *, data)

{

    int ret;

    char *kernel_type;

    char *kernel_dir;

    char *kernel_dev;

    unsigned long data_page;

    /*从用户空间复制到系统空间*/

    /*

    以下几个函数将用户态参数拷贝至内核态，在后面需要使用这些参数，包括:

    1. kernel_type:        挂载文件系统类型，如ext3

    2. kernel_dir:      载点路径

    3. dev_name:          设备名称

    4. data_pages:         选项信息

    */

    ret = copy_mount_string(type, &kernel_type);

    if (ret < )

        goto out_type;

    kernel_dir = getname(dir_name);

    if (IS_ERR(kernel_dir)) {

        ret = PTR_ERR(kernel_dir);

        goto out_dir;

    }

    ret = copy_mount_string(dev_name, &kernel_dev);

    if (ret < )

        goto out_dev;

    /*用户空间复制到系统空间，拷贝整个页面*/

    ret = copy_mount_options(data, &data_page);

    if (ret < )

        goto out_data;

    /*操作主体 调用do_mount 完成主要挂载工作*/

    ret = do_mount(kernel_dev, kernel_dir, kernel_type, flags,

        (void *) data_page);

    free_page(data_page);

out_data:

    kfree(kernel_dev);

out_dev:

    putname(kernel_dir);

out_dir:

    kfree(kernel_type);

out_type:

    return ret;

}

aaarticlea/png;base64,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" alt="" />

调用do_mount 完成主要挂载工作

long do_mount(char *dev_name, char *dir_name, char *type_page, unsigned long flags, void *data_page)

{

    struct path path;

    int retval = ;

    int mnt_flags = ;

    /* Discard magic */

    if ((flags & MS_MGC_MSK) == MS_MGC_VAL)

        flags &= ~MS_MGC_MSK;

    /* Basic sanity checks */

    if (!dir_name || !*dir_name || !memchr(dir_name, , PAGE_SIZE))

        return -EINVAL;

    if (data_page)

        ((char *)data_page)[PAGE_SIZE - ] = ;

    /* Default to relatime unless overriden */

    if (!(flags & MS_NOATIME))

        mnt_flags |= MNT_RELATIME;

    /* Separate the per-mountpoint flags */

    if (flags & MS_NOSUID)

        mnt_flags |= MNT_NOSUID;

    if (flags & MS_NODEV)

        mnt_flags |= MNT_NODEV;

    if (flags & MS_NOEXEC)

        mnt_flags |= MNT_NOEXEC;

    if (flags & MS_NOATIME)

        mnt_flags |= MNT_NOATIME;

    if (flags & MS_NODIRATIME)

        mnt_flags |= MNT_NODIRATIME;

    if (flags & MS_STRICTATIME)

        mnt_flags &= ~(MNT_RELATIME | MNT_NOATIME);

    if (flags & MS_RDONLY)

        mnt_flags |= MNT_READONLY;

    flags &= ~(MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_ACTIVE |

           MS_NOATIME | MS_NODIRATIME | MS_RELATIME| MS_KERNMOUNT |

           MS_STRICTATIME);

    /* ... and get the mountpoint */

    /*获得安装点path结构，用kern_path(),根据挂载点名称查找其dentry等信息 */

    retval = kern_path(dir_name, LOOKUP_FOLLOW, &path);

    if (retval)

        return retval;

    //LSM的hook挂载点

    retval = security_sb_mount(dev_name, &path, type_page, flags, data_page);

    if (retval)

        goto dput_out;

    //对于挂载标志的检查和初始化

    if (flags & MS_REMOUNT)

        //修改已经存在的文件系统参数,即改变超级块对象s_flags字段的安装标志

        retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags,

                    data_page);

    else if (flags & MS_BIND)

        //要求在系统目录树的另一个安装点上得文件或目录能够可见

        retval = do_loopback(&path, dev_name, flags & MS_REC);

    else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))

        retval = do_change_type(&path, flags);

    else if (flags & MS_MOVE)

        //改变已安装文件的安装点*

        retval = do_move_mount(&path, dev_name);

    else

        retval = do_new_mount(&path, type_page, flags, mnt_flags,

                      dev_name, data_page);

dput_out:

    path_put(&path);

    return retval;

}

retval = do_new_mount(&path, type_page, flags, mnt_flags, dev_name, data_page);，该函数接手来完成接下来的挂载工作

aaarticlea/png;base64,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" alt="" />

static int do_new_mount(struct path *path, char *type, int flags, int mnt_flags, char *name, void *data)

{

    struct vfsmount *mnt;

    if (!type)

        return -EINVAL;

    /*

    we need capabilities...

    必须是root权限

    */

    if (!capable(CAP_SYS_ADMIN))

        return -EPERM;

    lock_kernel();

    /*

    调用do_kern_mount()来完成挂载第一步

    1. 处理实际的安装操作并返回一个新的安装文件系统描述符地址

    2. 使用get_fs_type()辅助函数扫描已经注册文件系统链表，找到匹配的file_system_type实例，该辅助函数扫描已注册文件系统的链表，返回正确的项。如果没有找到匹配的文件系统，该例程就自动加载对应的模块

    3. 调用vfs_kern_mount用以调用特定于文件系统的get_sb函数读取sb结构(超级块)，并与mnt关联，初始化mnt并返回

    */

    mnt = do_kern_mount(type, flags, name, data);

    unlock_kernel();

    if (IS_ERR(mnt))

        return PTR_ERR(mnt);

    /*

    do_add_mount处理一些必须的锁定操作，并确保一个文件系统不会重复装载到同一位置，并将创建的vfsmount结构添加到全局结构中，以便在内存中形成一棵树结构

    */

    return do_add_mount(mnt, path, mnt_flags, NULL);

}

调用do_kern_mount()来完成挂载第一步

struct vfsmount * do_kern_mount(const char *fstype, int flags, const char *name, void *data)

{

    /*

    首先根据文件系统名称获取文件系统结构file_system_type

    内核中所有支持的文件系统的该结构通过链表保存

    */

    struct file_system_type *type = get_fs_type(fstype);

    struct vfsmount *mnt;

    if (!type)

        return ERR_PTR(-ENODEV);

    /*

    调用vfs_kern_mount()完成主要挂载

    1. 分配一个代表挂载结构的struct vfs_mount结构

    2. 调用具体文件系统的get_sb方法，从name代表的设备上读出超级块信息

    3. 设置挂载点的dentry结构为刚读出的设备的根目录

    */

    mnt = vfs_kern_mount(type, flags, name, data);

    if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&

        !mnt->mnt_sb->s_subtype)

        mnt = fs_set_subtype(mnt, fstype);

    put_filesystem(type);

    return mnt;

}

EXPORT_SYMBOL_GPL(do_kern_mount);

至此，我们第一部分的主要工作就完成了，在该部分的核心工作就是创建一个struct vfsmount，并读出文件系统超级块来初始化该结构。接下来就是将该结构添加到全局结构中，这就是do_add_mount()的主要工作，真正的挂载过程在函数do_add_mount()中完成

int do_add_mount(struct vfsmount *newmnt, struct path *path, int mnt_flags, struct list_head *fslist)

{

    int err;

    down_write(&namespace_sem);

    /*

    Something was mounted here while we slept

    如果在获取信号量的过程中别人已经进行了挂载，那么我们进入已挂载文件系统的根目录

    */

    while (d_mountpoint(path->dentry) &&

           follow_down(path))

        ;

    err = -EINVAL;

    if (!(mnt_flags & MNT_SHRINKABLE) && !check_mnt(path->mnt))

        goto unlock;

    /* Refuse the same filesystem on the same mount point */

    err = -EBUSY;

    if (path->mnt->mnt_sb == newmnt->mnt_sb &&

        path->mnt->mnt_root == path->dentry)

        goto unlock;

    err = -EINVAL;

    if (S_ISLNK(newmnt->mnt_root->d_inode->i_mode))

        goto unlock;

    newmnt->mnt_flags = mnt_flags;

    /*

    调用graft_tree()来实现文件系统目录树结构，其中newmnt是本次创建的vfsmount结构，path是挂载点信息

    */

    if ((err = graft_tree(newmnt, path)))

        goto unlock;

    if (fslist) /* add to the specified expiration list */

        list_add_tail(&newmnt->mnt_expire, fslist);

    up_write(&namespace_sem);

    return ;

unlock:

    up_write(&namespace_sem);

    mntput(newmnt);

    return err;

}

EXPORT_SYMBOL_GPL(do_add_mount);

主要是将当前新建的vfsmount结构与挂载点挂钩，并和挂载点所在的vfsmount形成一种父子关系结构。形成的结构图如下所示

Linux File System

至此，整个mount过程分析完毕

aaarticlea/png;base64,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*AiyEFAGAZkAJ4MaQAACwDUgAvhhQAgGVACuDFkAIAsAxIAbwYUgAAAKORAgAAGI0UAADAaKQAAABGIwUAADAaKQAAgNFIAQAAjEYKAABgNFIAAACjkQIAABiNFAAAwGikAAAARiMFAAAwGikAAPgd3XY1m7m0Zzz9PY2CFErmWv9qbM9hKcc8+VdwWvmoihV/aq2tUkJGC3UnYGlSAACwOLuaEkomq7bv09+1lNPq6pn6K1ilhBSJc8t9Uo4LFS/9mr08KQAABrNruWypZfl8ZOw1v3zaWlNSKLm2u1e8s3V/yvEe6crP8af2jKW01lo799Xsu1hYKLmWyF48ehv0UuD2oXS4GVLhjfTXdtCn1+Ei/yl83onItfQ3S3cbZ3tv30ih1t/lKvfDxQO36MVHMzcY+fSah+8lvOG3Buc2K5R8V7a8Df48iSoZPW1rrfXMUfn/FS7SUqgPR9WTZCwsIpv7l5Z2JveJt93qdSaxGVJyLZG/6ejpP4rdH8lO+cFbfaeSHA7MDykAAEbrtWuFDxuxVO6y3R3+tHt1GB5OMEoKlb1x5qaA/1Jaa/syFRr9eeTgqqd1f3oLRYZLhXKBh7L7i3gvLjTbp1tjW0xX3Jk5eIsBKdBf8+1VZvy9RLJ1Z3wNTj0TGX74bp/GhHdMXs8a1QxuCow+4u9T4dG3OTG80X01nQKjI3GHVtyWYvtkZguQAgAA3Xu4OTvYicX3z+pThwgevsSlUKmLkc+gC5wgGF2qXdyWQqW+/Oxqra3ycBF3eosW6l2t9c+vOyMT8yyDRRytu53/ZiJSxD83elpr576c6k+Bc7YYkALemnu/LtJSqINax38AuZbW2qnnwv1j7yPTrZsIPqOaxU2BcLJqaa0bxzGhpEifW1rr1udof4T94f3oau3c5aMjIx//K9i1tBTKSx+ttdbOTW74F/RBCgAAPE6zmNgUhab7rPvYrJXz+yn3IPmiKeCzVO96X0mR8vlkHDAxz+Itcqe19g59T3xWTlbtP9vi2Jq1tqrucYXwRvzD/nGl0fFbQysfcs8RjB6TnzWqmdwU8NvD7qpGUqA/8npuZgo0jyJSqHxj5rueQgoAwMsbnTwKzed7OjB5VMCufVoX2weluwe79zBzopr+POq71FOkQGtqv/Uf76vWolt0XzaRAiPzpfOrXStnP8bdrPGuvBt/Wbu4LUW6cnUaG16aN2tUM/1BCjQDUiCnSAEAwOJ8rxXoz0CW1rrzbT8yOVENJraxpzOXcg/Xb+Xuulrr7vdsaPz895+ngPMjo6RInDR6E6+as8Vk2dKDz/2zU2C4urPdGacYvBPz0e3hRQOzRzXLv0mB/h/Ffe/TKRA+IgUAAFNm3EHgflweXJ4WCQ8mqu73A+/n2yftiaezl5q8iE/FS49a/30KaKdxPH6BXn/Ns7Y4HPD4pXZTa24Xd+Xkmn2OCmj9eL4zeQpg5qhm/RX+MgXG/yjdq0P/awWmr3vwkAIAgGnW9+y7N1JENpNnTfs2K5T8eNnVWmun/SW1LpRcS5zfTz2dudTorX27e19a3gGIv04BrbVdP3Vv25NriYNSa3Bow3+LWltXufiakqFYqnj3zedagcGaO/Xip92NiBTjN0ZODcAqJaRQe7WxYwCzRuXrb1Ng4q9wX971uYMgfn4/a/ukAAAAr8rj+c7o1Ql8rwAAAIaxL9LDaxe6l3t82yAAYLVMf+WO+5h9Z/wKeNY35bTyUW/6d/8HQZP/QQAAAGYgBQAAMBopAACA0UgBAACMRgoAAGA0UgAAAKORAgAAGI0UAADAaKQAAABGIwUAADDa/wPyYvz+PlnsmwAAAABJRU5ErkJggg==" alt="" />

Relevant Link:

http://blog.csdn.net/kai_ding/article/details/9050429

http://blog.csdn.net/ding_kai/article/details/7106973

http://www.2cto.com/os/201202/119141.html

共享子树

对于文件系统的装载，Linux支持一些更高级的特性，可以更好地利用命名空间机制，这些扩展装载选项(我们将集合称之为"共享子树")对装载操作实现了以下几个新的属性

. 共享装载

一组已经装载的文件系统，装载事件将在这些文件系统之间传播。如果一个新的文件系统装载到该集合的某个成员中，则装载的文件系统就将复制到集合的所有其他成员中

. 从属装载

相比共享装载，它只是去掉了集合的所有成员之间的对称性。集合中有一个文件系统称之为主装载，主装载中的所有装载操作都会传播到从属装载中，但从属装载中的装载操作不会反向传播到主装载中

. 不可绑定的装载

不能通过绑定操作复制

. 私有装载

本质上就是经典的UNIX装载类型，它们可以装载到文件系统中多个位置，但装载事件不会传播到这种文件系统，也不会从这种文件系统向外传播

考虑以下这种情况

aaarticlea/png;base64,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" alt="" />

目录/virtual包含了root文件系统3个相同的绑定装载，/virtual/a、/virtual/b、/virtual/c。同时我们还需要任何装载在/media中的媒介还能在/virtual/a/media中可见，即使该媒介是在装载结构建立之后添加的，解决方案是用"共享装载"替换"绑定装载"。在这种情况下，任何装载在/media中的文件系统，都可以在其共享装载集合的其他成员(/、/virtual/a、/virtual/b、/virtual/c)中看到

如果将上文介绍的文件系统结构用作容器的基础，一个容器的每个用户都可以看到所有其他容器，但通常这不是我们想要的，一个解决问题的思路是将/virtual转换为"不可绑定子树"，其内容接下来不能被绑定装载看到，而容器中的用户也无法看到看到外部的情况
例如下面这种情况

aaarticlea/png;base64,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" alt="" />

我们继续思考这一场景的变形，在所有容器的用户都应该看到装载在/media的设备时(例如，装载到/media/usbstick的USB存储棒)，会引发另一个问题，即/media在各个容器之间共享到导致任何容器的用户都会看到由任何其他容器装载的媒介。解决这个问题的思路是将/media转换为从属装载，则能够保持我们想要的特性(在从属装载模式下，装载事件只会从/传播过来)，而且将各个容器彼此隔离开来
如下图所示

aaarticlea/png;base64,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" alt="" />

可以看到，用户A装载的camera不能被其他任何容器看到，而USB存储棒的装载点则会向下传播到/virtual的所有子目录中

回想我们之前学习的文件系统相关数据结构，这是共享子树的基础，如果"MS_SHARED"、"MS_PRIVATE"、"MS_SLAVE"、"MS_UNBINDABLE"其中某个标志传递到mount()系统调用，则do_mount将调用do_change_type改变给定装载的类型

long do_mount(char *dev_name, char *dir_name, char *type_page, unsigned long flags, void *data_page)

{

    ...

    else if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))

        retval = do_change_type(&path, flags);

    ...

\linux-2.6.32.63\fs\namespace.c

/*

 * recursively change the type of the mountpoint.

 */

static int do_change_type(struct path *path, int flag)

{

    struct vfsmount *m, *mnt = path->mnt;

    //如果设置了MS_REC标志，则所有装载的装载类型都将递归地改变

    int recurse = flag & MS_REC;

    int type = flag & ~MS_REC;

    int err = ;

    if (!capable(CAP_SYS_ADMIN))

        return -EPERM;

    if (path->dentry != path->mnt->mnt_root)

        return -EINVAL;

    down_write(&namespace_sem);

    if (type == MS_SHARED) {

        err = invent_group_ids(mnt, recurse);

        if (err)

            goto out_unlock;

    }

    spin_lock(&vfsmount_lock);

    //next_mnt提供了一个迭代器，能够遍历给定装载的所有子装载

    for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL))

        //change_mnt_propagation负责对struct vfsmount的实例设置适当的传播标志

        change_mnt_propagation(m, type);

    spin_unlock(&vfsmount_lock);

 out_unlock:

    up_write(&namespace_sem);

    return err;

}

\linux-2.6.32.63\fs\pnode.c

void change_mnt_propagation(struct vfsmount *mnt, int type)

{

    //对于共享装载是很简单的，用辅助函数set_mnt_shared设置MNT_SHARED标识就足够了

    if (type == MS_SHARED)

    {

        set_mnt_shared(mnt);

        return;

    }

    /*

    如果必须建立从属装载、私有装载、或不可绑定装载，内核必须重排装载相关的数据结构，使得目标vfsmount实例转化为从属装载，这是通过do_make_slave完成的，该函数执行以下步骤

    1. 需要对指定的vfsmount实例，找到一个主装载和任何可能的从属装载

        1) 内核搜索共享装载集合的各个成员，遍历到的各个vfsmount实例中，mnt_root成员与指定的vfsmount实例的mnt_root成员相同的第一个vfsmount实例，将指定为新的主装载

        2) 如果共享装载集合中不存在这样的成员，则将成员链表中第一个vfsmount实例用作主装载

    2. 如果已经发现一个新的主装载，那么将所述vfsmount实例以及所有从属装载的实例，都设置为新的主装载的从属装载

    3. 如果内核找不到一个新的主装载，所述装载的所有从属装载现在都是*的，它们不再有主装载了

    4. 无论如何，都会移除MNT_SHARED标志

    */

    do_make_slave(mnt);

    //在do_make_slave执行了这些调整后，change_mnt_propagation还需要一些步骤来处理不可绑定装载和私有装载

    if (type != MS_SLAVE)

    {

        //如果所属装载不是从属装载，则将其从从属装载链表中删除，并将mnt_master设置为NULL

        list_del_init(&mnt->mnt_slave);

        mnt->mnt_master = NULL;

        //不可绑定装载和私有装载都有没有主装载，对于不可绑定装载，将设置MS_UNBINDABLE标志，以便识别

        if (type == MS_UNBINDABLE)

            mnt->mnt_flags |= MNT_UNBINDABLE;

        else

            mnt->mnt_flags &= ~MNT_UNBINDABLE;

    }

}

在向新系统装载新的文件系统时，共享子树显然也影响到内核的行为，决定性的步骤在attach_recursive_mnt中进行

\linux-2.6.32.63\fs\namespace.c

static int attach_recursive_mnt(struct vfsmount *source_mnt, struct path *path, struct path *parent_path)

{

    LIST_HEAD(tree_list);

    struct vfsmount *dest_mnt = path->mnt;

    struct dentry *dest_dentry = path->dentry;

    struct vfsmount *child, *p;

    int err;

    if (IS_MNT_SHARED(dest_mnt)) {

        err = invent_group_ids(source_mnt, true);

        if (err)

            goto out;

    }

    /*

    首先，函数需要调查、读取装载事件应该传播到哪些装载

    propagate_mnt遍历装载目标的所有从属装载和共享装载，并分别使用mnt_set_mountpoint将新文件系统装载到这些文件系统中，所有受该操作影响的装载点都在tree_list中返回

    */

    err = propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list);

    if (err)

        goto out_cleanup_ids;

    //如果目标装载点是一个共享装载，那么新的装载及其所有子装载都会变为共享的

    if (IS_MNT_SHARED(dest_mnt))

    {

        for (p = source_mnt; p; p = next_mnt(p, source_mnt))

            set_mnt_shared(p);

    }

    spin_lock(&vfsmount_lock);

    if (parent_path)

    {

        detach_mnt(source_mnt, parent_path);

        attach_mnt(source_mnt, path);

        touch_mnt_namespace(parent_path->mnt->mnt_ns);

    }

    else

    {

        //最后，内核需要调用mnt_set_mountpoint、commit_tree结束装载过程，并将修改引入到普通装载的数据结构中

        mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt);

        commit_tree(source_mnt);

    }

    //需要注意的是，需要对共享装载集合的每个成员或每个从属装载分别调用commit_tree

    list_for_each_entry_safe(child, p, &tree_list, mnt_hash)

    {

        list_del_init(&child->mnt_hash);

        commit_tree(child);

    }

    spin_unlock(&vfsmount_lock);

    return ;

 out_cleanup_ids:

    if (IS_MNT_SHARED(dest_mnt))

        cleanup_group_ids(source_mnt, NULL);

 out:

    return err;

}

unmount系统调用

\linux-2.6.32.63\fs\namespace.c

SYSCALL_DEFINE2(umount, char __user *, name, int, flags)

{

    struct path path;

    int retval;

    int lookup_flags = ;

    if (flags & ~(MNT_FORCE | MNT_DETACH | MNT_EXPIRE | UMOUNT_NOFOLLOW))

        return -EINVAL;

    if (!(flags & UMOUNT_NOFOLLOW))

        lookup_flags |= LOOKUP_FOLLOW;

    retval = user_path_at(AT_FDCWD, name, lookup_flags, &path);

    if (retval)

        goto out;

    retval = -EINVAL;

    if (path.dentry != path.mnt->mnt_root)

        goto dput_and_out;

    if (!check_mnt(path.mnt))

        goto dput_and_out;

    retval = -EPERM;

    if (!capable(CAP_SYS_ADMIN))

        goto dput_and_out;

    //实际工作委托给do_umount

    retval = do_umount(path.mnt, flags);

dput_and_out:

    /* we mustn't call path_put() as that would clear mnt_expiry_mark */

    dput(path.dentry);

    mntput_no_expire(path.mnt);

out:

    return retval;

}

\linux-2.6.32.63\fs\namespace.c

static int do_umount(struct vfsmount *mnt, int flags)

{

    struct super_block *sb = mnt->mnt_sb;

    int retval;

    LIST_HEAD(umount_list);

    //LSM hook挂载点

    retval = security_sb_umount(mnt, flags);

    if (retval)

        return retval;

    /*

     * Allow userspace to request a mountpoint be expired rather than

     * unmounting unconditionally. Unmount only happens if:

     *  (1) the mark is already set (the mark is cleared by mntput())

     *  (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount]

     */

    if (flags & MNT_EXPIRE) {

        if (mnt == current->fs->root.mnt ||

            flags & (MNT_FORCE | MNT_DETACH))

            return -EINVAL;

        if (atomic_read(&mnt->mnt_count) != )

            return -EBUSY;

        if (!xchg(&mnt->mnt_expiry_mark, ))

            return -EAGAIN;

    }

    /*

     * If we may have to abort operations to get out of this

     * mount, and they will themselves hold resources we must

     * allow the fs to do things. In the Unix tradition of

     * 'Gee thats tricky lets do it in userspace' the umount_begin

     * might fail to complete on the first run through as other tasks

     * must return, and the like. Thats for the mount program to worry

     * about for the moment.

     */

     //如果定了特定于超级块的unmount_begin函数，则调用该函数。例如，这允许网络文件系统在强制卸载之前，终止与远程文件系统提供者的通信

    if (flags & MNT_FORCE && sb->s_op->umount_begin)

    {

        sb->s_op->umount_begin(sb);

    }

    /*

     * No sense to grab the lock for this test, but test itself looks

     * somewhat bogus. Suggestions for better replacement?

     * Ho-hum... In principle, we might treat that as umount + switch

     * to rootfs. GC would eventually take care of the old vfsmount.

     * Actually it makes sense, especially if rootfs would contain a

     * /reboot - static binary that would close all descriptors and

     * call reboot(9). Then init(8) could umount root and exec /reboot.

     */

    if (mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) {

        /*

         * Special case for "unmounting" root ...

         * we just try to remount it readonly.

         */

        down_write(&sb->s_umount);

        if (!(sb->s_flags & MS_RDONLY))

            retval = do_remount_sb(sb, MS_RDONLY, NULL, );

        up_write(&sb->s_umount);

        return retval;

    }

    down_write(&namespace_sem);

    spin_lock(&vfsmount_lock);

    event++;

    if (!(flags & MNT_DETACH))

        shrink_submounts(mnt, &umount_list);

    retval = -EBUSY;

    /*

    如果装载的文件系统不再需要(通过使用计数器判断)，或者指定了MNT_DETACH来强制卸载文件系统，则调用umount_tree

    实际工作委托为umount_tree、release_mounts

    1. umount_tree: 负责将计数器d_mounted减一

    2. release_mounts: 后者使用保存在mnt_mountpoint和mnt_parent中的数据，将环境恢复到所述文件系统装载之前的原始状态，被卸载文件系统的数据结构，也从内核链表中移除

    */

    if (flags & MNT_DETACH || !propagate_mount_busy(mnt, ))

    {

        if (!list_empty(&mnt->mnt_list))

            umount_tree(mnt, , &umount_list);

        retval = ;

    }

    spin_unlock(&vfsmount_lock);

    if (retval)

        security_sb_umount_busy(mnt);

    up_write(&namespace_sem);

    release_mounts(&umount_list);

    return retval;

}

自动过期

内核也提供了一些基础设施，允许装载自动过期。在任何进程或内核本身都"未使用"某个装载时，如果使用了自动过期机制，那么该装载将自动从vfsmount树中移除。当前NFS和AFS网络文件系统使用了该机制。所有子装载的vfsmount实例，如果被认为将自动到期，都需要使用vfsmount->mnt_expire链表元素，将其添加到链表中
接下来对链表周期性地应用mark_mounts_for_expiry即可
\linux-2.6.32.63\fs\namespace.c

/*

 * process a list of expirable mountpoints with the intent of discarding any

 * mountpoints that aren't in use and haven't been touched since last we came

 * here

 */

void mark_mounts_for_expiry(struct list_head *mounts)

{

    struct vfsmount *mnt, *next;

    LIST_HEAD(graveyard);

    LIST_HEAD(umounts);

    if (list_empty(mounts))

        return;

    down_write(&namespace_sem);

    spin_lock(&vfsmount_lock);

    /* extract from the expiration list every vfsmount that matches the

     * following criteria:

     * - only referenced by its parent vfsmount

     * - still marked for expiry (marked on the last call here; marks are

     *   cleared by mntput())

     */

    /*

    扫描所有链表项，如果装载的使用计数为1，即它只被父装载引用，那么它处于未使用状态，在找到这样的未使用装载时，将设置mnt_expiry_mark

    在mark_mounts_for_expiry下一次遍历链表时，如果发现未使用项设置了mnt_expiry_mark，那么将该装载从命名空间移除

    */

    list_for_each_entry_safe(mnt, next, mounts, mnt_expire)

    {

        if (!xchg(&mnt->mnt_expiry_mark, ) || propagate_mount_busy(mnt, ))

            continue;

        list_move(&mnt->mnt_expire, &graveyard);

    }

    while (!list_empty(&graveyard))

    {

        mnt = list_first_entry(&graveyard, struct vfsmount, mnt_expire);

        touch_mnt_namespace(mnt->mnt_ns);

        umount_tree(mnt, , &umounts);

    }

    spin_unlock(&vfsmount_lock);

    up_write(&namespace_sem);

    release_mounts(&umounts);

}

要注意的是，mntput负责清除mnt_expiry_mark标志位，这确保以下情形
如果一个装载已经处于过期链表中，然后又再次使用，那么在接下来调用mntput将计数器减一时，不会立即过期而被移除，代码流如下

. mark_mounts_for_expiry将未使用的装载标记为到期

. 此后，该装载再次被使用，因此其mnt_count加1，这防止了mark_mounts_for_expiry将该装载从命名空间中移除，尽管此时仍然设置着过期标志

. 在用mntput将使用计数减1时，该函数也会确认移除过期标记。下一周期的mark_mounts_for_expiry将照常开始工作

伪文件系统

文件系统未必需要底层块设备支持，它们可以使用内存作为后备存储器(如ramfs、tmpfs)，或者根本不需要后备存储器(如procfs、sysfs)，其内容是从内核数据结构包含的信息生成的。伪文件系统的例子包括

. 负责管理表示块设备的inode的bdev

. 处理管道的pipefs

. 处理套接字的sockfs

所有这些都出现在/proc/filesystems中，但不能装载，内核提供了装载标志"MS_NOUSER"，防止此类文件系统被装载，伪文件系统的加载和卸载都和普通文件系统都调用同一套函数API。内核可以使用kern_mount、kern_mount_data装载一个伪文件系统，最后调用vfs_kern_mount，将文件系统数据集成到VFS数据结构中。
在从用户层装载一个文件系统时，只有do_kern_mount并不够，还需要将文件和目录集成到用户可见的空间中，该工作由graft_tree处理，但如果设置了MS_NOUSER，则graft_tree拒绝工作

static int graft_tree(struct vfsmount *mnt, struct path *path)

{

    int err;

    if (mnt->mnt_sb->s_flags & MS_NOUSER)

        return -EINVAL;

    ...

}

需要明白的是，伪文件系统的结构内容对内核都是可用的，文件系统库提供了一些方法，可以用于向伪文件系统写入数据

0x2: 文件操作

操作整个文件系统是VFS的一个重要方面，但相对而言很少发生，因为除了可移动设备之外，文件系统都是在启动过程中装载，在关机时卸载。更常见的是对文件的频繁操作，所有系统进程都需要执行此类操作
为容许对文件的通用存取，而无需考虑所用的文件系统，VFS以各种系统调用的形式提供了用于文件处理的接口函数

1. 查找inode

一个主要操作是根据给定的文件名查找inode，nameidata结构用来向查找函数传递参数，并保存查找结果
有关struct nameidata的相关知识，请参阅另一篇文章

http://www.cnblogs.com/LittleHann/p/3865490.html

//搜索：0x9: struct nameidata

内核使用path_lookup函数查找路径或文件名
\linux-2.6.32.63\fs\namei.c

/*

Returns 0 and nd will be valid on success; Retuns error, otherwise.

除了所需的名称name和查找标志flags之外，该函数需要一个指向nameidata实例的指针，用作临时结果的"暂存器"

*/

static int do_path_lookup(int dfd, const char *name, unsigned int flags, struct nameidata *nd)

{

    //内核使用nameidata实例规定查找的起点，如果名称以/开始，则使用当前根目录的dentry和vfsmount实例(要考虑到chroot情况)，否则从当前进程的task_struct获得当前工作目录的数据

    int retval = path_init(dfd, name, flags, nd);

    if (!retval)

    {

        retval = path_walk(name, nd);

    }

    if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry && nd->path.dentry->d_inode))

    {

        audit_inode(name, nd->path.dentry);

    }

    if (nd->root.mnt)

    {

        path_put(&nd->root);

        nd->root.mnt = NULL;

    }

    return retval;

}

int path_lookup(const char *name, unsigned int flags,

            struct nameidata *nd)

{

    return do_path_lookup(AT_FDCWD, name, flags, nd);

}

其中的核心path_walk()的流程是一个不断穿过目录层次的过程，逐分量处理文件名或路径名，名称在循环内部分解为各个分量(通过一个或多个斜线分隔)，每个分量表示一个目录名，最后一个分量例外，总是文件名

static int path_walk(const char *name, struct nameidata *nd)

{

    current->total_link_count = ;

    return link_path_walk(name, nd);

}

/*

 * Wrapper to retry pathname resolution whenever the underlying

 * file system returns an ESTALE.

 *

 * Retry the whole path once, forcing real lookup requests

 * instead of relying on the dcache.

 */

static __always_inline int link_path_walk(const char *name, struct nameidata *nd)

{

    struct path save = nd->path;

    int result;

    /* make sure the stuff we saved doesn't go away */

    path_get(&save);

    result = __link_path_walk(name, nd);

    if (result == -ESTALE)

    {

        /* nd->path had been dropped */

        nd->path = save;

        path_get(&nd->path);

        nd->flags |= LOOKUP_REVAL;

        result = __link_path_walk(name, nd);

    }

    path_put(&save);

    return result;

}

static int __link_path_walk(const char *name, struct nameidata *nd)

{

    struct path next;

    struct inode *inode;

    int err;

    unsigned int lookup_flags = nd->flags;

    while (*name=='/')

        name++;

    if (!*name)

        goto return_reval;

    inode = nd->path.dentry->d_inode;

    if (nd->depth)

        lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);

    /* At this point we know we have a real path component. */

    for(;;) {

        unsigned long hash;

        struct qstr this;

        unsigned int c;

        nd->flags |= LOOKUP_CONTINUE;

        /*

        检查权限

        */

        err = exec_permission_lite(inode);

         if (err)

            break;

        this.name = name;

        c = *(const unsigned char *)name;

        //计算路径中下一个部分的散列值

        hash = init_name_hash();

        do {

            name++;

            //路径分量的每个字符都传递给partial_name_hash，用于计算一个递增的散列和，当路径分量的所有字符都已经计算，则将该散列和转换为最后的散列值，并保存到一个qstr中

            hash = partial_name_hash(c, hash);

            c = *(const unsigned char *)name;

        } while (c && (c != '/'));

        this.len = name - (const char *) this.name;

        this.hash = end_name_hash(hash);

        /* remove trailing slashes? */

        if (!c)

            goto last_component;

        while (*++name == '/');

        if (!*name)

            goto last_with_slashes;

        /*

         * "." and ".." are special - ".." especially so because it has

         * to be able to know about the current root directory and

         * parent relationships.

         */

        if (this.name[] == '.') switch (this.len) {

            default:

                break;

            case :

                if (this.name[] != '.')

                    break;

                /*

                如果路径分量中出现两个点(..)

                1. 当查找操作处理进程的根目录时，没有效果，因为根目录是没有父母了的

                2. 如果当前目录不是一个装载点的根目录，则将当前dentry对象的d_parent成员用作新的目录，因为它总是表示父目录

                3. 如果当前目录是一个已装载文件系统的根目录，保存在mnt_mountpoint和mnt_parent中的信息用于定义新的dentry和vfsmount对象

                */

                follow_dotdot(nd);

                inode = nd->path.dentry->d_inode;

                /* fallthrough */

            case :

                continue;

        }

        /*

         * See if the low-level filesystem might want

         * to use its own hash..

         */

        if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {

            err = nd->path.dentry->d_op->d_hash(nd->path.dentry,

                                &this);

            if (err < )

                break;

        }

        /*

        This does the actual lookups..

        如果路径分量是一个普通文件，则内核可以通过两种方法查找对应的dentry实例(以及对应的inode)

        1. 位于dentry cache中，访问它仅需很小的延迟

        2. 需要通过文件系统底层实现进行查找

        */

        err = do_lookup(nd, &this, &next);

        if (err)

            break;

        err = -ENOENT;

        inode = next.dentry->d_inode;

        if (!inode)

            goto out_dput;

        /*

        处理路径的最后一步是内核判断该分量是否为符号链接look

        */

        if (inode->i_op->follow_link) {

            err = do_follow_link(&next, nd);

            if (err)

                goto return_err;

            err = -ENOENT;

            inode = nd->path.dentry->d_inode;

            if (!inode)

                break;

        } else

            path_to_nameidata(&next, nd);

        err = -ENOTDIR;

        if (!inode->i_op->lookup)

            break;

        continue;

        /* here ends the main loop */

last_with_slashes:

        lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;

last_component:

        /* Clear LOOKUP_CONTINUE iff it was previously unset */

        nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;

        if (lookup_flags & LOOKUP_PARENT)

            goto lookup_parent;

        if (this.name[] == '.') switch (this.len) {

            default:

                break;

            case :

                if (this.name[] != '.')

                    break;

                follow_dotdot(nd);

                inode = nd->path.dentry->d_inode;

                /* fallthrough */

            case :

                goto return_reval;

        }

        if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {

            err = nd->path.dentry->d_op->d_hash(nd->path.dentry,

                                &this);

            if (err < )

                break;

        }

        err = do_lookup(nd, &this, &next);

        if (err)

            break;

        inode = next.dentry->d_inode;

        if (follow_on_final(inode, lookup_flags)) {

            err = do_follow_link(&next, nd);

            if (err)

                goto return_err;

            inode = nd->path.dentry->d_inode;

        } else

            path_to_nameidata(&next, nd);

        err = -ENOENT;

        if (!inode)

            break;

        if (lookup_flags & LOOKUP_DIRECTORY) {

            err = -ENOTDIR;

            if (!inode->i_op->lookup)

                break;

        }

        goto return_base;

lookup_parent:

        nd->last = this;

        nd->last_type = LAST_NORM;

        if (this.name[] != '.')

            goto return_base;

        if (this.len == )

            nd->last_type = LAST_DOT;

        else if (this.len ==  && this.name[] == '.')

            nd->last_type = LAST_DOTDOT;

        else

            goto return_base;

return_reval:

        /*

         * We bypassed the ordinary revalidation routines.

         * We may need to check the cached dentry for staleness.

         */

        if (nd->path.dentry && nd->path.dentry->d_sb &&

            (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) {

            err = -ESTALE;

            /* Note: we do not d_invalidate() */

            if (!nd->path.dentry->d_op->d_revalidate(

                    nd->path.dentry, nd))

                break;

        }

return_base:

        return ;

out_dput:

        path_put_conditional(&next, nd);

        break;

    }

    path_put(&nd->path);

return_err:

    return err;

}

static int exec_permission_lite(struct inode *inode)

{

    int ret;

    /*

    判断inode是否定义了permission方法

    */

    if (inode->i_op->permission)

    {

        ret = inode->i_op->permission(inode, MAY_EXEC);

        if (!ret)

            goto ok;

        return ret;

    }

    ret = acl_permission_check(inode, MAY_EXEC, inode->i_op->check_acl);

    if (!ret)

        goto ok;

    if (capable(CAP_DAC_OVERRIDE) || capable(CAP_DAC_READ_SEARCH))

        goto ok;

    return ret;

ok:

    //LSM hook挂载点

    return security_inode_permission(inode, MAY_EXEC);

}

循环一直重复下去，直至到达文件名的末尾，如果内核发现文件名不再出现，则确认已经到达文件名末尾
do_lookup起始于一个路径分量，并且包含最初目录数据的nameidata实例，最终返回与之相关的inode

. 内核首先试图在dentry缓存中查找inode，使用__d_lookup函数，找到匹配的数据，并不意味着它是最新的，必须调用底层文件系统的dentry_operation中的d_revalidate函数，来检查缓存项是否仍然有效

    ) 如果有效: 则将其作为缓存搜索的结果返回

    ) 如果无效: 必须在底层文件系统中发起一个查找操作

如果缓存没有找到，也必须在底层文件系统中发起一个查找操作，即在内存中建立dentry结构

do_follow_link，在内核跟踪符号链接时，它必须要注意死循环符号链接的可能性

static inline int do_follow_link(struct path *path, struct nameidata *nd)

{

    //检查链接限制

    int err = -ELOOP;

    if (current->link_count >= MAX_NESTED_LINKS)

        goto loop;

    if (current->total_link_count >= )

        goto loop;

    BUG_ON(nd->depth >= MAX_NESTED_LINKS);

    cond_resched();

    err = security_inode_follow_link(path->dentry, nd);

    if (err)

        goto loop;

    current->link_count++;

    current->total_link_count++;

    nd->depth++;

    err = __do_follow_link(path, nd);

    current->link_count--;

    nd->depth--;

    return err;

loop:

    path_put_conditional(path, nd);

    path_put(&nd->path);

    return err;

}

task_struct结构包含两个计数变量，用于跟踪连接

strcut task_struct

{

    ..

    //link_count用于防止递归循环

    int link_count;

    //total_link_count限制路径名中连接的最大数目

    int total_link_count;

    ..

}

2. 打开文件

在读写文件之前，必须先打开文件，从应用程序的角度来看，这是通过标准库的open函数完成的，该函数返回一个文件描述符。该函数使用了同名的open()系统调用
\linux-2.6.32.63\fs\open.c

SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode)

{

    long ret;

    /*

    检查是否应该不考虑用户层传递的标志，总是强行设置O_LARGEFILE。如果底层处理器字长是64位系统，就需要设置这个选项

    */

    if (force_o_largefile())

    {

        flags |= O_LARGEFILE;

    } 

    //调用do_sys_open完成实际功能

    ret = do_sys_open(AT_FDCWD, filename, flags, mode);

    /* avoid REGPARM breakage on x86: */

    asmlinkage_protect(, ret, filename, flags, mode);

    return ret;

}

long do_sys_open(int dfd, const char __user *filename, int flags, int mode)

{

    /*获取文件名称，由getname()函数完成，其内部首先创建存取文件名称的空间，然后从用户空间把文件名拷贝过来*/

    char *tmp = getname(filename);

    int fd = PTR_ERR(tmp);

    if (!IS_ERR(tmp))

    {

        /*

        在内核中，每个打开的文件由一个文件描述符表示，该描述符在特定于进程的数组中充当位置索引(task_strcut->files->fd_array)，该数组的元素包含了file结构，其中包含了每个打开文件所有必要的信息

        获取一个可用的fd，此函数调用alloc_fd()函数从fd_table中获取一个可用fd,并进行初始化

        */

        fd = get_unused_fd_flags(flags);

        if (fd >= )

        {

            /*fd获取成功则开始打开文件，此函数是主要完成打开功能的函数，用于获取对应文件的inode*/

            struct file *f = do_filp_open(dfd, tmp, flags, mode, );

            if (IS_ERR(f))

            {

                /*打开失败，释放fd*/

                put_unused_fd(fd);

                fd = PTR_ERR(f);

            }

            else

            {

                //文件如果已经被打开了，调用fsnotify_open()函数

                fsnotify_open(f->f_path.dentry);

                //将文件指针安装在fd数组中，每个进程都会将打开的文件句柄保存在fd_array[]数组中

                fd_install(fd, f);

            }

        }

        //释放放置从用户空间拷贝过来的文件名的存储空间

        putname(tmp);

    }

    return fd;

}

do_filp_open完成查找文件inode的主要工作

struct file *do_filp_open(int dfd, const char *pathname, int open_flag, int mode, int acc_mode)

{

    /* 若干变量声明 */

    struct file *filp;

    struct nameidata nd;

    int error;

    struct path path;

    struct dentry *dir;

    int count = ;

    int will_write;

    /*改变参数flag的值，具体做法是flag+1*/

    int flag = open_to_namei_flags(open_flag);

    /*设置访问权限*/

    if (!acc_mode)

    {

        acc_mode = MAY_OPEN | ACC_MODE(flag);

    } 

    /* O_TRUNC implies we need access checks for write permissions */

    /* 根据O_TRUNC标志设置写权限 */

    if (flag & O_TRUNC)

    {

        acc_mode |= MAY_WRITE;

    } 

    /* Allow the LSM permission hook to distinguish append access from general write access. */

    /* 设置O_APPEND标志 */

    if (flag & O_APPEND)

    {

        acc_mode |= MAY_APPEND;

    } 

    /* The simplest case - just a plain lookup. */

    /* 如果不是创建文件 */

    if (!(flag & O_CREAT))

    {

        /*

        当内核要访问一个文件的时候，第一步要做的是找到这个文件，而查找文件的过程在vfs里面是由path_lookup或者path_lookup_open函数来完成的

        这两个函数将用户传进来的字符串表示的文件路径转换成一个dentry结构，并建立好相应的inode和file结构，将指向file的描述符返回用户

        用户随后通过文件描述符，来访问这些数据结构

        */

        error = path_lookup_open(dfd, pathname, lookup_flags(flag), &nd, flag);

        if (error)

        {

            return ERR_PTR(error);

        }

        goto ok;

    }

    /*

     * Create - we need to know the parent.

     */

    //path-init为查找作准备工作，path_walk真正上路查找，这两个函数联合起来根据一段路径名找到对应的dentry

    error = path_init(dfd, pathname, LOOKUP_PARENT, &nd);

    if (error)

    {

        return ERR_PTR(error);

    }

    /*

    这个函数相当重要，是整个NFS的名字解析函数，其实也是NFS得以构筑的函数

    该函数采用一个for循环，对name路径根据目录的层次，一层一层推进，直到终点或失败。在推进的过程中，一步步建立了目录树的dentry和对应的inode

    */

    error = path_walk(pathname, &nd);

    if (error)

    {

        if (nd.root.mnt)

        {

            /*减少dentry和vsmount得计数*/

            path_put(&nd.root);

        }

        return ERR_PTR(error);

    }

    if (unlikely(!audit_dummy_context()))

    {

        /*保存inode节点信息*/

        audit_inode(pathname, nd.path.dentry);

    } 

    /*

     * We have the parent and last component. First of all, check

     * that we are not asked to creat(2) an obvious directory - that

     * will not do.

     */

    error = -EISDIR;

    /*父节点信息*/

    if (nd.last_type != LAST_NORM || nd.last.name[nd.last.len])

    {

        goto exit_parent;

    } 

    error = -ENFILE;

    /* 返回特定的file结构体指针 */

    filp = get_empty_filp();

    if (filp == NULL)

    {

        goto exit_parent;

    }

    /* 填充nameidata结构 */

    nd.intent.open.file = filp;

    nd.intent.open.flags = flag;

    nd.intent.open.create_mode = mode;

    dir = nd.path.dentry;

    nd.flags &= ~LOOKUP_PARENT;

    nd.flags |= LOOKUP_CREATE | LOOKUP_OPEN;

    if (flag & O_EXCL)

    {

        nd.flags |= LOOKUP_EXCL;

    }

    mutex_lock(&dir->d_inode->i_mutex);

    /*从哈希表中查找nd对应的dentry*/

    path.dentry = lookup_hash(&nd);

    path.mnt = nd.path.mnt;

do_last:

    error = PTR_ERR(path.dentry);

    if (IS_ERR(path.dentry))

    {

        mutex_unlock(&dir->d_inode->i_mutex);

        goto exit;

    }

    if (IS_ERR(nd.intent.open.file))

    {

        error = PTR_ERR(nd.intent.open.file);

        goto exit_mutex_unlock;

    }

    /* Negative dentry, just create the file */

    /*如果此dentry结构没有对应的inode节点，说明是无效的，应该创建文件节点 */

    if (!path.dentry->d_inode)

    {

        /*

         * This write is needed to ensure that a

         * ro->rw transition does not occur between

         * the time when the file is created and when

         * a permanent write count is taken through

         * the 'struct file' in nameidata_to_filp().

        */

        /*write权限是必需的*/

        error = mnt_want_write(nd.path.mnt);

        if (error)

        {

            goto exit_mutex_unlock;

        }

        /*按照namei格式的flag open*/

        error = __open_namei_create(&nd, &path, flag, mode);

        if (error)

        {

            mnt_drop_write(nd.path.mnt);

            goto exit;

        }

        /*根据nameidata 得到相应的file结构*/

        filp = nameidata_to_filp(&nd, open_flag);

        if (IS_ERR(filp))

        {

            ima_counts_put(&nd.path, acc_mode & (MAY_READ | MAY_WRITE | MAY_EXEC));

        }

        /*放弃写权限*/

        mnt_drop_write(nd.path.mnt);

        if (nd.root.mnt)

        {

            /*计数减一*/

            path_put(&nd.root);

        }

        return filp;

    }

    /*

     * It already exists.

     */

    /*要打开的文件已经存在*/

    mutex_unlock(&dir->d_inode->i_mutex);

    /*保存inode节点*/

    audit_inode(pathname, path.dentry);

    error = -EEXIST;

    /*flag标志检查代码*/

    if (flag & O_EXCL)

    {

        goto exit_dput;

    } 

    if (__follow_mount(&path))

    {

        error = -ELOOP;

        if (flag & O_NOFOLLOW)

        {

            goto exit_dput;

        }

    }

    error = -ENOENT;

    if (!path.dentry->d_inode)

    {

        goto exit_dput;

    }

    if (path.dentry->d_inode->i_op->follow_link)

    {

        goto do_link;

    }

    /*路径装化为相应的nameidata结构*/

    path_to_nameidata(&path, &nd);

    error = -EISDIR;

    /*如果是文件夹*/

    if (path.dentry->d_inode && S_ISDIR(path.dentry->d_inode->i_mode))

    {

        goto exit;

    }

ok:

    /*

     * Consider:

     * 1. may_open() truncates a file

     * 2. a rw->ro mount transition occurs

     * 3. nameidata_to_filp() fails due to

     *    the ro mount.

     * That would be inconsistent, and should

     * be avoided. Taking this mnt write here

     * ensures that (2) can not occur.

     */

    /*检测是否截断文件标志*/

    will_write = open_will_write_to_fs(flag, nd.path.dentry->d_inode);

    if (will_write)

    {

        /*要截断的话就要获取写权限*/

        error = mnt_want_write(nd.path.mnt);

        if (error)

        {

            goto exit;

        }

    }

    //may_open执行权限检测、文件打开和truncate的操作

    error = may_open(&nd.path, acc_mode, flag);

    if (error)

    {

        if (will_write)

        {

            mnt_drop_write(nd.path.mnt);

        }

        goto exit;

    }

    filp = nameidata_to_filp(&nd, open_flag);

    if (IS_ERR(filp))

    {

        ima_counts_put(&nd.path, acc_mode & (MAY_READ | MAY_WRITE | MAY_EXEC));

    }

    /*

     * It is now safe to drop the mnt write

     * because the filp has had a write taken

     * on its behalf.

     */

    //安全的放弃写权限

    if (will_write)

    {

        mnt_drop_write(nd.path.mnt);

    }

    if (nd.root.mnt)

    {

        path_put(&nd.root);

    }

    return filp;

exit_mutex_unlock:

    mutex_unlock(&dir->d_inode->i_mutex);

exit_dput:

    path_put_conditional(&path, &nd);

exit:

    if (!IS_ERR(nd.intent.open.file))

    {

        release_open_intent(&nd);

    }

exit_parent:

    if (nd.root.mnt)

    {

        path_put(&nd.root);

    }

    path_put(&nd.path);

    return ERR_PTR(error);

do_link:

//允许遍历连接文件，则手工找到连接文件对应的文件

    error = -ELOOP;

    if (flag & O_NOFOLLOW)

    {

        //不允许遍历连接文件，返回错误

        goto exit_dput;

    }

    /*

     * This is subtle. Instead of calling do_follow_link() we do the

     * thing by hands. The reason is that this way we have zero link_count

     * and path_walk() (called from ->follow_link) honoring LOOKUP_PARENT.

     * After that we have the parent and last component, i.e.

     * we are in the same situation as after the first path_walk().

     * Well, almost - if the last component is normal we get its copy

     * stored in nd->last.name and we will have to putname() it when we

     * are done. Procfs-like symlinks just set LAST_BIND.

     */

    /* 以下是手工找到链接文件对应的文件dentry结构代码 */

    //设置查找LOOKUP_PARENT标志

    nd.flags |= LOOKUP_PARENT;

    //判断操作是否安全

    error = security_inode_follow_link(path.dentry, &nd);

    if (error)

    {

        goto exit_dput;

    }

    //处理符号链接

    error = __do_follow_link(&path, &nd);

    if (error)

    {

        /* Does someone understand code flow here? Or it is only

         * me so stupid? Anathema to whoever designed this non-sense

         * with "intent.open".

         */

        release_open_intent(&nd);

        if (nd.root.mnt)

        {

            path_put(&nd.root);

        }

        return ERR_PTR(error);

    }

    nd.flags &= ~LOOKUP_PARENT;

    //检查最后一段文件或目录名的属性情况

    if (nd.last_type == LAST_BIND)

    {

        goto ok;

    }

    error = -EISDIR;

    if (nd.last_type != LAST_NORM)

    {

        goto exit;

    }

    if (nd.last.name[nd.last.len])

    {

        __putname(nd.last.name);

        goto exit;

    }

    error = -ELOOP;

    //出现回环标志: 循环超过32次

    if (count++==)

    {

        __putname(nd.last.name);

        goto exit;

    }

    dir = nd.path.dentry;

    mutex_lock(&dir->d_inode->i_mutex);

    //更新路径的挂接点和dentry

    path.dentry = lookup_hash(&nd);

    path.mnt = nd.path.mnt;

    __putname(nd.last.name);

    goto do_last;

}

接下来，将控制权返回用户进程，返回文件描述符之前，fd_install必须将file实例放置到进程task_struct的files_fd数组中

3. 读取和写入

在文件成功打开后，进程将使用内核提供的read或write系统调用，来读取或修改文件的数据，入口例程是sys_read、sys_write

aaarticlea/png;base64,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" alt="" />

读写数据涉及到一个复杂的缓冲区和缓存系统，这些用于提供系统性能

回想我们之前学习的文件系统相关数据结构，这是共享子树的基础，如果"MS_SHARED"、"MS_PRIVATE"、"MS_SLAVE"、"MS_UNBINDABLE"其中某个标志传递到mount()系统调用，则do_mount将调用do_change_type改变给定装载的类型

5. 标准函数

VFS层提供的有用资源是用于读写数据的标准函数，这些操作对所有文件系统来说，在一定程度上都是相同的，如果数据所在的块是已知的，如果数数据所在的块是已知的，则首先查询页缓存，如果数据并未保存在其中，则向对应的块设备发出读请求，如果对每个文件系统都需要实现这些操作，则会导致代码大量复制，Linux内核应该极力避免这种情况的发生

0x1: 通用读取例程

几乎所有的文件系统都使用库程序generic_file_read来读取数据，它同步地读取数据(从外部调用者的角度来看是同步的)，即它保证在函数返回到调用者时，所需数据已经在内存中，在实现中，实际读取操作委托给一个异步例程，然后等待该例程返回
\linux-2.6.32.63\fs\read_write.c

ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos)

{

    struct iovec iov = { .iov_base = buf, .iov_len = len };

    struct kiocb kiocb;

    ssize_t ret;

    //init_sync_kiocb初始化一个kiocb实例，用于控制异步输入/输出操作

    init_sync_kiocb(&kiocb, filp);

    kiocb.ki_pos = *ppos;

    kiocb.ki_left = len;

    //实际共走委托给特定于文件系统的异步读取操作，保存在struct file_operations的aio_read成员中，该例程是异步的，因此在例程返回到调用者时，无法保证数据已经读取完毕

    for (;;)

    {

        ret = filp->f_op->aio_read(&kiocb, &iov, , kiocb.ki_pos);

        //返回值-EIOCBRETRY表示读请求正在排队，尚未处理(底层设备会对请求进行重排优化，并cache请求)

        if (ret != -EIOCBRETRY)

            break;

        //在请求队列正在排队的情况下，wait_on_retry_sync_kiocb将一直等待，直至数据进入内存，在等待时，进程进入睡眠状态，使得其他进程可以利用CPU

        wait_on_retry_sync_kiocb(&kiocb);

    }

    if (-EIOCBQUEUED == ret)

        ret = wait_on_sync_kiocb(&kiocb);

    *ppos = kiocb.ki_pos;

    return ret;

}

1. 异步读取

\linux-2.6.32.63\mm\filemap.c

ssize_t generic_file_aio_read(struct kiocb *iocb, const struct iovec *iov, unsigned long nr_segs, loff_t pos)

{

    struct file *filp = iocb->ki_filp;

    ssize_t retval;

    unsigned long seg;

    size_t count;

    loff_t *ppos = &iocb->ki_pos;

    count = ;

    /*

    generic_segment_checks确认读请求包含的参数有效之后，有两种不同的读模式需要区分

    1. 如果设置了O_DIRECT标志，则数据直接读取，不使用页缓存，这个时候必须用generic_file_direct_IO

    2. 否则调用do_generic_file_read，将对文件的读操作转换为对映射的读操作

    */

    retval = generic_segment_checks(iov, &nr_segs, &count, VERIFY_WRITE);

    if (retval)

        return retval;

    /* coalesce the iovecs and go direct-to-BIO for O_DIRECT */

    if (filp->f_flags & O_DIRECT)

    {

        loff_t size;

        struct address_space *mapping;

        struct inode *inode;

        mapping = filp->f_mapping;

        inode = mapping->host;

        if (!count)

            goto out; /* skip atime */

        size = i_size_read(inode);

        if (pos < size)

        {

            retval = filemap_write_and_wait_range(mapping, pos, pos + iov_length(iov, nr_segs) - );

            if (!retval)

            {

                retval = mapping->a_ops->direct_IO(READ, iocb, iov, pos, nr_segs);

            }

            if (retval > )

                *ppos = pos + retval;

            if (retval)

            {

                file_accessed(filp);

                goto out;

            }

        }

    }

    for (seg = ; seg < nr_segs; seg++)

    {

        read_descriptor_t desc;

        desc.written = ;

        desc.arg.buf = iov[seg].iov_base;

        desc.count = iov[seg].iov_len;

        if (desc.count == )

            continue;

        desc.error = ;

        do_generic_file_read(filp, ppos, &desc, file_read_actor);

        retval += desc.written;

        if (desc.error)

        {

            retval = retval ?: desc.error;

            break;

        }

        if (desc.count > )

            break;

    }

out:

    return retval;

}

EXPORT_SYMBOL(generic_file_aio_read);

2. 从映射读取

/source/mm/filemap.c

void do_generic_mapping_read(struct address_space *mapping, struct file_ra_state *ra, struct file *filp, loff_t *ppos, read_descriptor_t *desc, read_actor_t actor)

{

    struct inode *inode = mapping->host;

    pgoff_t index;

    pgoff_t last_index;

    pgoff_t prev_index;

    unsigned long offset;      /* offset into pagecache page */

    unsigned int prev_offset;

    int error;

    index = *ppos >> PAGE_CACHE_SHIFT;

    prev_index = ra->prev_pos >> PAGE_CACHE_SHIFT;

    prev_offset = ra->prev_pos & (PAGE_CACHE_SIZE-);

    last_index = (*ppos + desc->count + PAGE_CACHE_SIZE-) >> PAGE_CACHE_SHIFT;

    offset = *ppos & ~PAGE_CACHE_MASK;

    /*

    该函数使用映射机制，将文件中需要读取的部分映射到内存页中，它由一个大的无限循环组成，持续向内存页读入数据，直至所有文件数据(不在任何缓存中的文件数据)都传输到内存中

    */

    for (;;)

    {

        struct page *page;

        pgoff_t end_index;

        loff_t isize;

        unsigned long nr, ret;

        cond_resched();

    find_page:

        //1. find_get_page检查页是否已经包含在页缓存中

        page = find_get_page(mapping, index);

        if (!page)

        {

            //如果没哟iuze调用page_cache_sync_readahead发出一个同步预读请求

            page_cache_sync_readahead(mapping, ra, filp, index, last_index - index);

            //2. 由于预读机制在很大程度上能够保证数据现在已经进入缓存，因此再次调用find_get_page查找该页这次仍然有一定的几率失败，那么必须直接进行读取操作

            page = find_get_page(mapping, index);

            if (unlikely(page == NULL))

                goto no_cached_page;

        }

        //3. 如果设置了页标志PG_readahead(内核用PageReadahead检查)，内核必须调用page_cache_async_readahead启动一个异步预读操作

        if (PageReadahead(page))

        {

            //这里内核并不等待预读操作结束，只要有空闲时间，就会执行读操作

            page_cache_async_readahead(mapping, ra, filp, page, index, last_index - index);

        }

        //4. 虽然页在缓存中，但其数据未必是最新的，这需要使用Page_Uptodate检查

        if (!PageUptodate(page))

            goto page_not_up_to_date;

    page_ok:

        isize = i_size_read(inode);

        end_index = (isize - ) >> PAGE_CACHE_SHIFT;

        if (unlikely(!isize || index > end_index))

        {

            page_cache_release(page);

            goto out;

        } 

        nr = PAGE_CACHE_SIZE;

        if (index == end_index)

        {

            nr = ((isize - ) & ~PAGE_CACHE_MASK) + ;

            if (nr <= offset)

            {

                page_cache_release(page);

                goto out;

            }

        }

        nr = nr - offset; 

        if (mapping_writably_mapped(mapping))

            flush_dcache_page(page); 

        if (prev_index != index || offset != prev_offset)

            //对页的访问必须用mark_page_accessed标记，在需要从物理内存换出数据时，需要判断页的活动程度，这个标记很重要

            mark_page_accessed(page);

        prev_index = index; 

        //actor例程(file_read_actor)将适当的页映射到用户地址空间

        ret = actor(desc, page, offset, nr);

        offset += ret;

        index += offset >> PAGE_CACHE_SHIFT;

        offset &= ~PAGE_CACHE_MASK;

        prev_offset = offset;

        page_cache_release(page);

        if (ret == nr && desc->count)

            continue;

        goto out;

    ..

}

EXPORT_SYMBOL(do_generic_mapping_read);

aaarticlea/png;base64,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" alt="" />
0x2: 失效机制

内存映射通常调用由VFS层提供的filemap_fault标准例程来读取未保存在缓存中的页
/source/mm/filemap.c

int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)

{

    int error;

    struct file *file = vma->vm_file;

    struct address_space *mapping = file->f_mapping;

    struct file_ra_state *ra = &file->f_ra;

    struct inode *inode = mapping->host;

    pgoff_t offset = vmf->pgoff;

    struct page *page;

    pgoff_t size;

    int ret = ;

    size = (i_size_read(inode) + PAGE_CACHE_SIZE - ) >> PAGE_CACHE_SHIFT;

    if (offset >= size)

        return VM_FAULT_SIGBUS;

    /*

     * Do we have something in the page cache already?

     */

    page = find_get_page(mapping, offset);

    if (likely(page)) {

        /*

         * We found the page, so try async readahead before

         * waiting for the lock.

         */

        do_async_mmap_readahead(vma, ra, file, page, offset);

        lock_page(page);

        /* Did it get truncated? */

        if (unlikely(page->mapping != mapping))

        {

            unlock_page(page);

            put_page(page);

            goto no_cached_page;

        }

    }

    else

    {

        /* No page in the page cache at all */

        do_sync_mmap_readahead(vma, ra, file, offset);

        count_vm_event(PGMAJFAULT);

        ret = VM_FAULT_MAJOR;

retry_find:

        //代码从对find_lock_page的第一次调用开始，重试查找页的操作

        page = find_lock_page(mapping, offset);

        if (!page)

            goto no_cached_page;

    }

    /*

     * We have a locked page in the page cache, now we need to check

     * that it's up-to-date. If not, it is going to be due to an error.

     */

    if (unlikely(!PageUptodate(page)))

        goto page_not_uptodate;

    /*

     * Found the page and have a reference on it.

     * We must recheck i_size under page lock.

     */

    size = (i_size_read(inode) + PAGE_CACHE_SIZE - ) >> PAGE_CACHE_SHIFT;

    if (unlikely(offset >= size)) {

        unlock_page(page);

        page_cache_release(page);

        return VM_FAULT_SIGBUS;

    }

    ra->prev_pos = (loff_t)offset << PAGE_CACHE_SHIFT;

    vmf->page = page;

    return ret | VM_FAULT_LOCKED;

no_cached_page:

    /*

     * We're only likely to ever get here if MADV_RANDOM is in

     * effect.

     */

    error = page_cache_read(file, offset);

    /*

     * The page we want has now been added to the page cache.

     * In the unlikely event that someone removed it in the

     * meantime, we'll just come back here and read it again.

     */

    if (error >= )

        goto retry_find;

    /*

     * An error return from page_cache_read can result if the

     * system is low on memory, or a problem occurs while trying

     * to schedule I/O.

     */

    if (error == -ENOMEM)

        return VM_FAULT_OOM;

    return VM_FAULT_SIGBUS;

page_not_uptodate:

    /*

     * Umm, take care of errors if the page isn't up-to-date.

     * Try to re-read it _once_. We do this synchronously,

     * because there really aren't any performance issues here

     * and we need to check for errors.

     */

    ClearPageError(page);

    error = mapping->a_ops->readpage(file, page);

    if (!error)

    {

        wait_on_page_locked(page);

        if (!PageUptodate(page))

            error = -EIO;

    }

    page_cache_release(page);

    if (!error || error == AOP_TRUNCATED_PAGE)

        goto retry_find;

    /* Things didn't work out. Return zero to tell the mm layer so. */

    shrink_readahead_size_eio(file, ra);

    return VM_FAULT_SIGBUS;

}

EXPORT_SYMBOL(filemap_fault);

可以看到，Linux VFS的文件读取总体原理如下

. 从外部调用者来看，读写一定是同步的

. 在VFS内部，使用异步+睡眠等待的形式进行异步读取

. 根据O_DIRECT标志位决定

    ) 采用直接读取(向底层硬件设备发起读取请求)

    ) 从映射中读取

0x3: 权限检查

vfs_permission是VFS层的标准函数，用于检查是否允许以指定的某种权限访问给定的inode，该权限可以是

. MAY_READ

. MAY_WRITE

. MAY_EXEC

/source/fs/namei.c

int vfs_permission(struct nameidata *nd, int mask)

{

    return permission(nd->path.dentry->d_inode, mask, nd);

}

int permission(struct inode *inode, int mask, struct nameidata *nd)

{

    int retval, submask;

    struct vfsmount *mnt = NULL;

    if (nd)

        mnt = nd->path.mnt;

    if (mask & MAY_WRITE)

    {

        umode_t mode = inode->i_mode;

        //禁止以写模式访问只读文件系统

        if (IS_RDONLY(inode) && (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))

            return -EROFS;

        //禁止以写模式访问不可修改的文件

        if (IS_IMMUTABLE(inode))

            return -EACCES;

    }

    if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))

    {

        if (mnt && (mnt->mnt_flags & MNT_NOEXEC))

            return -EACCES;

    }

    //通常的permission例程并不理解MAY_APPEND

    submask = mask & ~MAY_APPEND;

    //接下来，实际工作委托给特定于文件系统的权限检查例程

    if (inode->i_op && inode->i_op->permission)

    {

        retval = inode->i_op->permission(inode, submask, nd);

        if (!retval)

        {

            if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode) && !(inode->i_mode & S_IXUGO))

            return -EACCES;

        }

    }

    else

    {

        retval = generic_permission(inode, submask, NULL);

    }

    if (retval)

        return retval;

    retval = devcgroup_inode_permission(inode, mask);

    if (retval)

        return retval;

    //LSM Hook Point

    return security_inode_permission(inode, mask, nd);

}

/source/fs/namei.c
generic_permission不仅需要将所述的inode和请求的权限作为参数，还需要一个回调函数check_acl，用于检查ACL

int generic_permission(struct inode *inode, int mask, int (*check_acl)(struct inode *inode, int mask))

{

    int ret;

    /*

     * Do the basic POSIX ACL permission checks.

    首先，内核需要判断应该使用用户、组、还是其他人的inode权限

    1. 如果当前进程的文件系统UID与inode的UID相同，则需要使用对所有者设置的权限

    2. 如果inode的GID包含在当前进程所属组的列表中，那么需要使用组权限

    3. 如果并非上述两种情况，则需要"其他用户"对inode的权限

    */

    ret = acl_permission_check(inode, mask, check_acl);

    if (ret != -EACCES)

        return ret;

    //如果DAC检查失败，并不意味着禁止所要求的操作，因为对能力的检查可能允许该操作

    /*

     * Read/write DACs are always overridable.

     * Executable DACs are overridable if at least one exec bit is set.

     */

    if (!(mask & MAY_EXEC) || execute_ok(inode))

        /*

        如果进程有CAP_DAC_OVERRIDE能力，那么对以下情形，都可以授予所请求的权限

        1. 读或写访问，没有请求执行访问

        2. 设置了3个可能的执行位中的一个或多个

        3. inode表示目录

        */

        if (capable(CAP_DAC_OVERRIDE))

            return ;

    /*

     * Searching includes executable on directories, else just read.

     */

    mask &= MAY_READ | MAY_WRITE | MAY_EXEC;

    if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE)))

        /*

        另一个发挥作用的能力是CAP_DAC_READ_SEARCH，该能力允许在读取文件和搜索目录时，撤销DAC权限的设置，如果有该能力，那么对以下情形，可以允许访问

        1. 请求读操作

        2. 所述inode是一个目录，没有请求写访问

        */

        if (capable(CAP_DAC_READ_SEARCH))

            return ;

    return -EACCES;

}

/source/fs/namei.c

static int acl_permission_check(struct inode *inode, int mask, int (*check_acl)(struct inode *inode, int mask))

{

    umode_t            mode = inode->i_mode;

    mask &= MAY_READ | MAY_WRITE | MAY_EXEC;

    //如果current_fsuid与文件的UID相同，则将mode值右移6位，使得对应于"所有者"的权限位移动到最低位上

    if (current_fsuid() == inode->i_uid)

        mode >>= ;

    else

    {

        if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl)

        {

            int error = check_acl(inode, mask);

            if (error != -EAGAIN)

                return error;

        }

        //检查所属的所有组

        if (in_group_p(inode->i_gid))

            mode >>= ;

    }

    //如果UID和GID的检查都失败，那么不需要将mode值做移位操作，因为对应于"其他用户"的权限位本来就在最低位上

    /*

    If the DACs are ok we don't need any capability check.

    对选定的权限位进行DAC(自主访问控制 discretionary access control)

    */

    if ((mask & ~mode) == )

        return ;

    return -EACCES;

}

对Linux permission检查逻辑梳理如下

. ACL检查

    ) UID

    ) GID

    ) OTHER

. 如果所述inode有一个相关的ACL，并且向generic_permission传递了一个用于ACL的权限检查回调函数，那么在将当前进程的fsuid与所述文件的UID比较之后，将调用该回调函数，如果给出了ACL回调函数，那么DAC检查是可以跳过的，因为ACL检查中包含了标准的DAC检查，否则，将直接返回ACL检查的结果

. 即使ACL拒绝了所要求的访问，进程能力设置仍然可能允许该操作

Copyright (c) 2015 LittleHann All rights reserved

Linux File System的更多相关文章

  1. chattr lsattr linux file system attributes - linux 文件系统扩展属性

    我们使用 linux 文件系统扩展属性,能够对linux文件系统进行进一步保护:从而给文件 赋予一些额外的限制:在有些情况下,能够对我们的系统提供保护: chattr命令用来改变文件属性.这项指令可改 ...

  2. 磁盘、分区及Linux文件系统 &lbrack;Disk&comma; Partition&comma; Linux File System&rsqb;

    1.磁盘基础知识 1.1 物理结构 硬盘的物理结构一般由磁头与碟片.电动机.主控芯片与排线等部件组成:当主电动机带动碟片旋转时,副电动机带动一组(磁头)到相对应的碟片上并确定读取正面还是反面的碟面,磁 ...

  3. key directories in the linux file system

    Key directories in the file system: */: Root directory (base of file system) /bin: Executable progra ...

  4. Linux File System Change Monitoring Technology、Notifier Technology

    catalog . 为什么要监控文件系统 : hotplug . udev . fanotify(fscking all notification system) . inotify . code e ...

  5. File System Design Case Studies

    SRC=http://www.cs.rutgers.edu/~pxk/416/notes/13-fs-studies.html Paul Krzyzanowski April 24, 2014 Int ...

  6. Linux 执行partprobe命令时遇到Unable to open &sol;dev&sol;sr0 read-write &lpar;Read-only file system&rpar;

    在使用fdisk创建分区时,我们会使用partprobe命令可以使kernel重新读取分区信息,从而避免重启系统,但是有时候会遇到下面错误信息"Warning: Unable to open ...

  7. Linux文件虚拟机系统只读Read-only file system的快速解决方法

    问题描述:上周公司的私有云(底层架构是Openstack+KVM,目前稳定性还不够好,开发团队在改进中)一个计算节点挂掉,之后恢复后发现这个计算节点的所有Linux系统都变成只读了,复制文件提示:Re ...

  8. Linux操作系统报：read-only file system

    在对集群测试过程中发现系统中某一节点中的磁盘变成read-only file system,从而导致测试任务出错,从网上查找资料,找到以下解决方案: 这个报错的意思是硬盘属性变成只读,不可写入: VO ...

  9. Linux出现Read-only file system错误的解决方法

    造成这个问题的解决办法大多数是由于非正常关机后导致文件系统受损引起的,在系统重新启动之后,受损分区就会被Linux自己主动挂载为仅仅读.解决办法是通过fsck来修复文件系统,然后重新启动就可以,下面是 ...

随机推荐

  1. CSS属性之float学习心得

    全文参考:http://www.linzenews.com/program/net/2331.html 我们来看看CSS重要属性--float. 以下内容分为如下小节: 1:float属性 2:flo ...

  2. 为dedecms文章列表页标题增加序号&comma;第二页开始才显示第x页

    想必大伙建站都会写文章,随着时间的推移,你的智慧结晶会越来越多,一般的建站程序早帮你想好了,把这些文章做成一个列表,比如dedecms栏目列表,便于观众浏览,但有个问题就是dedecms文章列表页标题 ...

  3. 网络编程中常见地址结构与转换（IPv4&sol;IPv6&rpar;

    1. sockaddr/sockaddr_in/in_addr (IPv4).sockaddr6_in/in6_addr/addrinfo (IPv6) struct sockaddr { unsig ...

  4. 【转】qtp安装时问题

    1.安装qtp后要重启机器. 2.插件选择错误, 处理方式:重新启动QTP,勾选 WEB插件; 3.在安装QTP后,或者禁用IE浏览器里的一些ActiveX控件后,正常录制QTP时,对象识别不了;(保 ...

  5. Android AsyncHttpClient

    Android Asynchronous Http Client A Callback-Based Http Client Library for Android   Tweet Downloadve ...

  6. 关于MVC EntityType has no key defined的问题

    关于MVC EntityType has no key defined的问题 在测试MVC时发现一个奇怪的问题,在Model中定义数据类时,如 public class UserInfo { publ ...

  7. liunx下search文件内容的几种方式

    第一种.使用vim来search内容 /regex_word,从上到下匹配 ?regex_word,从下到上匹配 n是获取下一个匹配字符串,N是获取上一个匹配字符串. 第二种.使用grep命令 gre ...

  8. &lbrack;js学习笔记&rsqb; 原型链理解

    js中只有对象,包括对象,函数,常量等. prototype 只有函数里有这个属性. 对象里可以设置这个属性,但是没这个属性的意义 prototype指向一个对象,可以添加想要的方法. 该对象里有一个 ...

  9. linux&lowbar;shell 编程学习-初识she&&num;39&semi;ll

    一.she'll编程规范 1.she'll脚本命名一般为英文的大小写; 2.不能用特殊符号.空格来命名; 3.she'll脚本后缀以.sh结尾; 4.不建议she'll命名为纯数字,一般以脚本功能命名 ...

  10. LeetCode--038--报数&lpar;java&rpar;

    报数序列是一个整数序列,按照其中的整数的顺序进行报数,得到下一个数.其前五项如下: 1. 1 2. 11 3. 21 4. 1211 5. 111221 1 被读作  "one 1&quot ...

相关文章