open,close系统调用

小鱼儿 2022-03-26 15:26 163阅读 0赞

http://blog.chinaunix.net/space.php?uid=12567959&do=blog&id=161001

**open系统调用**

open()系统调用的服务例程为sys\_open()函数，该函数接收的参数为：要打开的文件的路径名filename、访问模式的一些标志flags，以及如果该文件被创建所需要的许可位掩码mode。如果该系统调用成功，就返回一个文件描述符，也就是指向文件对象的指针数组current->files-> fd\_array或者current-> files-> fdtable.fd中新分配给文件的索引；否则，返回\-1。

open()系统调用的所有标志

\---------------------------------------------------------------------

include/asm-generic/fcntl.h

\#defineO\_ACCMODE00000003

\#defineO\_RDONLY 00000000   /\* 为只读而打开 \*/

\#defineO\_WRONLY 00000001   /\* 为只写而打开 \*/

\#defineO\_RDWR      00000002  /\* 为读和写而打开 \*/

\#ifndefO\_CREAT /\*如果文件不存在则创建它 \*/

\#defineO\_CREAT     00000100   /\* not fcntl \*/

\#endif

\#ifndefO\_EXCL /\*对于O\_CREAT标志，如果文件已经存在，则失败 \*/

\#defineO\_EXCL      00000200   /\* not fcntl \*/

\#endif

\#ifndefO\_NOCTTY /\*从不把文件看作终端 \*/

\#defineO\_NOCTTY 00000400   /\* not fcntl \*/

\#endif

\#ifndefO\_TRUNC /\*截断文件（删除所有的现有内容） \*/

\#defineO\_TRUNC     00001000   /\* not fcntl \*/

\#endif

\#ifndefO\_APPEND /\*总是在文件末尾写 \*/

\#defineO\_APPEND 00002000

\#endif

\#ifndefO\_NONBLOCK /\*非阻塞打开 \*/

\#defineO\_NONBLOCK  00004000

\#endif

\#ifndefO\_DSYNC /\*同步写（阻塞，直到物理写终止） \*/

\#defineO\_DSYNC     00010000   /\* used to be O\_SYNC, see below \*/

\#endif

\#ifndefFASYNC /\*通过信号发出I/O事件通知 \*/

\#defineFASYNC      00020000   /\* fcntl, for BSD compatibility \*/

\#endif

\#ifndefO\_DIRECT

\#defineO\_DIRECT 00040000   /\* direct disk access hint \*/

\#endif

/\*大型文件（文件长度大于off\_t所能表示的范围但小于off64\_t）\*/

\#ifndefO\_LARGEFILE

\#defineO\_LARGEFILE 00100000

\#endif

\#ifndefO\_DIRECTORY /\*如果文件不是一个目录，则失败 \*/

\#defineO\_DIRECTORY 00200000   /\* must be a directory \*/

\#endif

\#ifndefO\_NOFOLLOW /\*不解析路径名尾部的符号链接 \*/

\#defineO\_NOFOLLOW  00400000   /\* don't follow links \*/

\#endif

\#ifndefO\_NOATIME /\*不更新索引节点的访问时间。\*/

\#defineO\_NOATIME01000000

\#endif

\#ifndefO\_CLOEXEC

\#defineO\_CLOEXEC02000000   /\* set close\_on\_exec \*/

\#endif

\---------------------------------------------------------------------

有一些标志的定义是因体系结构而异的。

sys\_open()定义如下：

\---------------------------------------------------------------------

fs/open.c

SYSCALL\_DEFINE3(open,const char \_\_user \*, filename, int, flags, int, mode)

long ret;

if (force\_o\_largefile())

flags |= O\_LARGEFILE;

ret = do\_sys\_open(AT\_FDCWD, filename, flags,mode);

/\* avoid REGPARM breakage on x86: \*/

asmlinkage\_protect(3, ret, filename, flags,mode);

return ret;

\---------------------------------------------------------------------

这个函数的操作如下：

首先，调用force\_o\_largefile()来判断是否支持大文件，若是，则设置标志的O\_LARGEFILE位。force\_o\_largefile()其实是一个宏。这个宏也是因体系结构而异的。

其次，调用do\_sys\_open(AT\_FDCWD, filename, flags, mode)来完成实际的打开文件的任务。下面有更详细说明。

最后，调用asmlinkage\_protect()以使系统调用正确返回。它也是一个宏，为了防止编译器错误而设。其他平台为空，只有x86平台有定义，为：

\---------------------------------------------------------------------

arch/x86/include/asm/linkage.h

/\*

\* Make sure the compiler doesn't do anythingstupid with the

\* arguments on the stack - they are owned bythe \*caller\*, not

\* the callee. This just fools gcc into notspilling into them,

\* and keeps it from doing tailcall recursionand/or using the

\* stack slots for temporaries, since they arelive and "used"

\* all the way to the end of the function.

\* NOTE! On x86-64, all the arguments are inregisters, so this

\* only matters on a 32-bit kernel.

\*/\#define asmlinkage\_protect(n, ret, args...)\\

\_\_asmlinkage\_protect\#\#n(ret, \#\#args)

\#define\_\_asmlinkage\_protect\_n(ret, args...) \\

\_\_asm\_\_ \_\_volatile\_\_ ("" :"=r" (ret) : "0" (ret), \#\#args)

\#define\_\_asmlinkage\_protect0(ret) \\

\_\_asmlinkage\_protect\_n(ret)

\#define\_\_asmlinkage\_protect1(ret, arg1) \\

\_\_asmlinkage\_protect\_n(ret, "g"(arg1))

\#define\_\_asmlinkage\_protect2(ret, arg1, arg2) \\

\_\_asmlinkage\_protect\_n(ret, "g"(arg1), "g" (arg2))

\#define\_\_asmlinkage\_protect3(ret, arg1, arg2, arg3) \\

\_\_asmlinkage\_protect\_n(ret, "g"(arg1), "g" (arg2), "g" (arg3))

\---------------------------------------------------------------------

do\_sys\_open()函数定义如下：

\---------------------------------------------------------------------

fs/open.c

longdo\_sys\_open(int dfd, const char \_\_user \*filename, int flags, int mode)

char \*tmp = getname(filename);

int fd = PTR\_ERR(tmp);

if (!IS\_ERR(tmp)) \{

fd = get\_unused\_fd\_flags(flags);

if (fd >= 0) \{

struct file \*f = do\_filp\_open(dfd,tmp, flags, mode, 0);

if (IS\_ERR(f)) \{

put\_unused\_fd(fd);

fd = PTR\_ERR(f);

\} else \{

fsnotify\_open(f->f\_path.dentry);

fd\_install(fd, f);

putname(tmp);

return fd;

\---------------------------------------------------------------------

第一个参数是多么的眼熟啊，查找路径名的do\_path\_lookup()函数的第一个参数也是它，用于说明查找路径名的基目录。关于它，前面路径名查找已有说明了。其余参数则是sys\_open()将传进来的参数传给了它。

这个函数执行如下操作：

1、调用getname(filename)从进程地址空间读取文件的路径名，将路径名的地址存放在局部变量tmp。getname(filename)本质上，首先从名为"names\_cache"路径名slab缓存中分配内存区，然后将路径名从用户空间复制到该内存区中。

2、调用get\_unused\_fd\_flags(flags)从当前进程的文件描述符表中找一个空位。其定义为：

\---------------------------------------------------------------------

include/linux/file.h

\#defineget\_unused\_fd\_flags(flags) alloc\_fd(0, (flags))

\---------------------------------------------------------------------

这是一个宏，仅仅是对alloc\_fd()函数特殊参数下调用的别名，对alloc\_fd()函数定义如下：

\---------------------------------------------------------------------

fs/file.c

/\*

\* allocate a file descriptor, mark it busy.

\*/

intalloc\_fd(unsigned start, unsigned flags)

struct files\_struct \*files =current->files;

unsigned int fd;

int error;

struct fdtable \*fdt;

spin\_lock(&files->file\_lock);

repeat:

fdt = files\_fdtable(files);

fd = start;

if (fd < files->next\_fd)

fd = files->next\_fd;

if (fd < fdt->max\_fds)

fd = find\_next\_zero\_bit(fdt->open\_fds->fds\_bits,

fdt->max\_fds, fd);

error = expand\_files(files, fd);

if (error < 0)

goto out;

/\*

\* Ifwe needed to expand the fs array we

\*might have blocked - try again.

\*/

if (error)

goto repeat;

if (start <= files->next\_fd)

files->next\_fd = fd + 1;

FD\_SET(fd, fdt->open\_fds);

if (flags & O\_CLOEXEC)

FD\_SET(fd, fdt->close\_on\_exec);

else

FD\_CLR(fd, fdt->close\_on\_exec);

error = fd;

\#if1

/\* Sanity check \*/

if (rcu\_dereference\_raw(fdt->fd\[fd\]) !=NULL) \{

printk(KERN\_WARNING "alloc\_fd: slot%d not NULL!\\n", fd);

rcu\_assign\_pointer(fdt->fd\[fd\], NULL);

\#endif

out:

spin\_unlock(&files->file\_lock);

return error;

\---------------------------------------------------------------------

这个函数执行如下操作：

a.将current->files->next\_fd字段赋值给局部变量。

b.调用find\_next\_zero\_bit(fdt->open\_fds->fds\_bits,fdt->max\_fds, fd)来在文件描述符表中寻找下一个可以分配的文件描述符。这个函数也是因体系结构而异，系统中通用的函数定义为：

\---------------------------------------------------------------------

lib/find\_next\_bit.c

unsignedlong find\_next\_zero\_bit(const unsigned long \*addr,

unsigned long size,  unsigned long offset)

const unsigned long \*p = addr +BITOP\_WORD(offset);

unsigned long result = offset &~(BITS\_PER\_LONG-1);

unsigned long tmp;

if (offset >= size)

returnsize;

size -= result;

offset %= BITS\_PER\_LONG;

if (offset) \{

tmp = \*(p++);

tmp |= ~0UL >> (BITS\_PER\_LONG -offset);

if (size < BITS\_PER\_LONG)

goto found\_first;

if (~tmp)

goto found\_middle;

size -= BITS\_PER\_LONG;

result += BITS\_PER\_LONG;

while (size & ~(BITS\_PER\_LONG-1)) \{

if (~(tmp = \*(p++)))

goto found\_middle;

result += BITS\_PER\_LONG;

size -= BITS\_PER\_LONG;

if (!size)

return result;

tmp = \*p;

found\_first:

tmp |= ~0UL << size;

if (tmp == ~0UL)  /\* Are any bits zero? \*/

return result + size;    /\* Nope. \*/

found\_middle:

return result + ffz(tmp);

\---------------------------------------------------------------------

(1)、上面的BITOP\_WORD(offset)清一色定义为：

\#defineBITOP\_WORD(nr)     ((nr) / BITS\_PER\_LONG)

首先求得第一个要查找的long的位置。

(2)、offset &~(BITS\_PER\_LONG-1)等价于offset除以32再乘以32，以此来求得所要查找的第一个字第0位在表中的位置，只不过会比除法运算效率高很多。

(3)、如果传递的起始查找位置甚至大于最大可能值，则返回最大可能值。

(4)、查找第一个0位所在的long型值的位置。而局部变量tmp中会保存该long型量的值。

(5)、返回查找到的第一个0位的位置或可能的最大值。

c.调用expand\_files(files,fd)，来扩展文件描述符表，files\_struct的fd\_array数组成员可以在打开的文件较少时使用，但当打开的文件较多时，就会对文件描述符表进行扩展。

d.更新files->next\_fd字段，将分配的文件描述符添加进fdt->open\_fds，如果设置了O\_CLOEXEC则将文件描述符添加进fdt->close\_on\_exec，若没有，则清除fdt->close\_on\_exec中的相应位。

e.返回文件描述符。

3、调用do\_filp\_open(dfd,tmp, flags, mode, 0)函数，传递给它的参数依次为查找路径名的基目录、文件路径名、访问模式标志以及许可权位掩码、访问模式位。这个函数定义为：

\---------------------------------------------------------------------

fs/namei.c

1761/\*

1762 \* Note that the low bits of the passed in"open\_flag"

1763 \* are not the same as in the local variable"flag". See

1764 \* open\_to\_namei\_flags() for more details.

1765 \*/

1766struct file \*do\_filp\_open(int dfd, const char \*pathname,

1767                int open\_flag, int mode, intacc\_mode)

1768\{

1769        struct file \*filp;

1770        struct nameidata nd;

1771        int error;

1772        struct path path;

1773        int count = 0;

1774        int flag =open\_to\_namei\_flags(open\_flag);

1775        int force\_reval = 0;

1776

1777        if (!(open\_flag & O\_CREAT))

1778                mode = 0;

1779

1780        /\*

1781         \* O\_SYNC is implemented as\_\_O\_SYNC|O\_DSYNC.  As many places only

1782         \* check for O\_DSYNC if the need anysyncing at all we enforce it's

1783         \* always set instead of having todeal with possibly weird behaviour

1784         \* for malicious applications settingonly \_\_O\_SYNC.

1785         \*/

1786        if (open\_flag & \_\_O\_SYNC)

1787                open\_flag |= O\_DSYNC;

1788

1789        if (!acc\_mode)

1790                acc\_mode = MAY\_OPEN |ACC\_MODE(open\_flag);

1791

1792        /\* O\_TRUNC implies we need accesschecks for write permissions \*/

1793        if (open\_flag & O\_TRUNC)

1794                acc\_mode |= MAY\_WRITE;

1795

1796        /\* Allow the LSM permission hook todistinguish append

1797           access from general write access.\*/

1798        if (open\_flag & O\_APPEND)

1799                acc\_mode |= MAY\_APPEND;

1800

1801        /\* find the parent \*/

1802reval:

1803        error = path\_init(dfd, pathname,LOOKUP\_PARENT, &nd);

1804        if (error)

1805                return ERR\_PTR(error);

1806        if (force\_reval)

1807                nd.flags |= LOOKUP\_REVAL;

1808

1809        current->total\_link\_count = 0;

1810        error = link\_path\_walk(pathname,&nd);

1811        if (error) \{

1812                filp = ERR\_PTR(error);

1813                goto out;

1814        \}

1815        if (unlikely(!audit\_dummy\_context())&& (open\_flag & O\_CREAT))

1816                audit\_inode(pathname,nd.path.dentry);

1817

1818        /\*

1819         \* We have the parent and lastcomponent.

1820         \*/

1821

1822        error = -ENFILE;

1823        filp = get\_empty\_filp();

1824        if (filp == NULL)

1825                goto exit\_parent;

1826        nd.intent.open.file = filp;

1827        filp->f\_flags = open\_flag;

1828        nd.intent.open.flags = flag;

1829        nd.intent.open.create\_mode = mode;

1830        nd.flags &= ~LOOKUP\_PARENT;

1831        nd.flags |= LOOKUP\_OPEN;

1832        if (open\_flag & O\_CREAT) \{

1833                nd.flags |= LOOKUP\_CREATE;

1834                if (open\_flag & O\_EXCL)

1835                        nd.flags |=LOOKUP\_EXCL;

1836        \}

1837        if (open\_flag & O\_DIRECTORY)

1838                nd.flags |= LOOKUP\_DIRECTORY;

1839        if (!(open\_flag & O\_NOFOLLOW))

1840                nd.flags |= LOOKUP\_FOLLOW;

1841        filp = do\_last(&nd, &path,open\_flag, acc\_mode, mode, pathname);

1842        while (unlikely(!filp)) \{ /\* trailingsymlink \*/

1843                struct path holder;

1844                struct inode \*inode =path.dentry->d\_inode;

1845                void \*cookie;

1846                error = -ELOOP;

1847                /\* S\_ISDIR part is a temporaryautomount kludge \*/

1848                if (!(nd.flags &LOOKUP\_FOLLOW) && !S\_ISDIR(inode->i\_mode))

1849                        goto exit\_dput;

1850                if (count++ == 32)

1851                        goto exit\_dput;

1852                /\*

1853                 \* This is subtle. Instead ofcalling do\_follow\_link() we do

1854                 \* the thing by hands. Thereason is that this way we have zero

1855                 \* link\_count and path\_walk()(called from ->follow\_link)

1856                 \* honoringLOOKUP\_PARENT.  After that we have theparent and

1857                 \* last component, i.e. we arein the same situation as after

1858                 \* the first path\_walk().  Well, almost - if the last component

1859                 \* is normal we get its copystored in nd->last.name and we will

1860                 \* have to putname() it whenwe are done. Procfs-like symlinks

1861                 \* just set LAST\_BIND.

1862                 \*/

1863                nd.flags |= LOOKUP\_PARENT;

1864                error =security\_inode\_follow\_link(path.dentry, &nd);

1865                if (error)

1866                        goto exit\_dput;

1867                error =\_\_do\_follow\_link(&path, &nd, &cookie);

1868                if (unlikely(error)) \{

1869                        /\* nd.path had beendropped \*/

1870                        if (!IS\_ERR(cookie)&& inode->i\_op->put\_link)

1871                                inode->i\_op->put\_link(path.dentry, &nd, cookie);

1872                        path\_put(&path);

1873                        release\_open\_intent(&nd);

1874                        filp = ERR\_PTR(error);

1875                        goto out;

1876                \}

1877                holder = path;

1878                nd.flags &=~LOOKUP\_PARENT;

1879                filp = do\_last(&nd,&path, open\_flag, acc\_mode, mode, pathname);

1880                if(inode->i\_op->put\_link)

1881                        inode->i\_op->put\_link(holder.dentry, &nd, cookie);

1882                path\_put(&holder);

1883        \}

1884out:

1885        if (nd.root.mnt)

1886                path\_put(&nd.root);

1887        if (filp == ERR\_PTR(-ESTALE)&& !force\_reval) \{

1888                force\_reval = 1;

1889                goto reval;

1890        \}

1891        return filp;

1892

1893exit\_dput:

1894        path\_put\_conditional(&path,&nd);

1895        if (!IS\_ERR(nd.intent.open.file))

1896                release\_open\_intent(&nd);

1897exit\_parent:

1898        path\_put(&nd.path);

1899        filp = ERR\_PTR(error);

1900        goto out;

1901\} \---------------------------------------------------------------------

这个函数一次执行下列步骤：

a.把访问模式拷贝到flag标志中，但是，用特殊的格式对方问模式标志O\_RDONLY、O\_WRONLY和O\_RDWR进行编码。由函数open\_to\_namei\_flags()完成，其定义如下：

\---------------------------------------------------------------------

fs/namei.c

/\*

\* Note that while the flag value (low twobits) for sys\_open means:

\* 00 -read-only

\* 01 -write-only

\* 10 -read-write

\* 11 -special

\* it is changed into

\* 00 -no permissions needed

\* 01 -read-permission

\* 10 -write-permission

\* 11 -read-write

\* for the internal routines (ieopen\_namei()/follow\_link() etc)

\* This is more logical, and also allows the 00"no perm needed"

\* to be used for symlinks (where thepermissions are checked

\* later).

\*/

staticinline int open\_to\_namei\_flags(int flag)

if ((flag+1) & O\_ACCMODE)

flag++;

return flag;

\---------------------------------------------------------------------

注释中说的已经很清楚了。

根据open\_flag原来的值适当更新打开标志open\_flag，根据open\_flag适当更新访问模式acc\_mode

b.调用path\_init(dfd,pathname, LOOKUP\_PARENT, &nd)，将查找的路径名的基路径找到，并赋给nd的path字段。注意在这个函数中设置了nd->flags的LOOKUP\_PARENT，也就是要查找路径名最后一个分量的父目录。

c.设置current->total\_link\_count为0。

d.调用link\_path\_walk(pathname,&nd)查找路径名最后一个分量的父母的路径path结构体，保存在nd.path中。因为，路径名的最后一个分量有可能是不存在的而需要创建。

e.调用get\_empty\_filp()函数从file的slab缓冲区filp\_cachep中分配一个file结构，并初始化它的一些字段。如果返回值为NULL，则返回错误码\-ENFILE的指针形式。

f.设置nd.intent.open.file为上一步分配的file结构的地址filp，设置filp的打开文件时所制定的标志f\_flags为传递进来并经过适当修改的打开标志open\_flag。设置nd.intent.open.flags为访问模式flag，设置nd.intent.open.create\_mode为创建模式mode。清除nd.flags的LOOKUP\_PARENT标志，设置其LOOKUP\_OPEN标志。如果在打开标志中设置了O\_CREAT，则设置nd.flags的LOOKUP\_CREATE标志，若同时设置了打开标志的O\_EXCL，则同时设置nd.flags的OOKUP\_EXCL。若设置了打开标志的O\_DIRECTORY，则设置nd.flags的LOOKUP\_DIRECTORY。若没有设置打开标志的O\_NOFOLLOW位，则设置nd.flags的LOOKUP\_FOLLOW。

即是根据打开标志来设置nd.flags的相应位。这些标志似乎都只与查找的路径名的最后一个分量有关。

g.调用do\_last()来完成路径名最后一个分量的处理。又是一个非常长的函数，它接受六个参数，nd为前面查找的路径名最后一个分量的父目录的nameidata结构，path为一个path结构的局部变量，打开标志，acc\_mode，创建模式（如果需要的话）mode和路径名。该函数定义如下：

\---------------------------------------------------------------------

fs/namei.c

1617static struct file \*do\_last(struct nameidata \*nd, struct path \*path,

1618                            int open\_flag, int acc\_mode,

1619                            int mode, constchar \*pathname)

1620\{

1621        struct dentry \*dir =nd->path.dentry;

1622        struct file \*filp;

1623        int error = -EISDIR;

1624

1625        switch (nd->last\_type) \{

1626        case LAST\_DOTDOT:

1627                follow\_dotdot(nd);

1628                dir = nd->path.dentry;

1629        case LAST\_DOT:

1630                if(nd->path.mnt->mnt\_sb->s\_type->fs\_flags & FS\_REVAL\_DOT) \{

1631                        if(!dir->d\_op->d\_revalidate(dir, nd)) \{

1632                                error =-ESTALE;

1633                                goto exit;

1634                        \}

1635                \}

1636                /\* fallthrough \*/

1637        case LAST\_ROOT:

1638                if (open\_flag & O\_CREAT)

1639                        goto exit;

1640                /\* fallthrough \*/

1641        case LAST\_BIND:

1642                audit\_inode(pathname, dir);

1643                goto ok;

1644        \}

1645

1646        /\* trailing slashes? \*/

1647        if (nd->last.name\[nd->last.len\])\{

1648                if (open\_flag & O\_CREAT)

1649                        goto exit;

1650                nd->flags |=LOOKUP\_DIRECTORY | LOOKUP\_FOLLOW;

1651        \}

1652

1653        /\* just plain open? \*/

1654        if (!(open\_flag & O\_CREAT)) \{

1655                error = do\_lookup(nd,&nd->last, path);

1656                if (error)

1657                        goto exit;

1658                error = -ENOENT;

1659                if(!path->dentry->d\_inode)

1660                        goto exit\_dput;

1661                if(path->dentry->d\_inode->i\_op->follow\_link)

1662                        return NULL;

1663                error = -ENOTDIR;

1664                if (nd->flags &LOOKUP\_DIRECTORY) \{

1665                        if(!path->dentry->d\_inode->i\_op->lookup)

1666                                gotoexit\_dput;

1667                \}

1668                path\_to\_nameidata(path, nd);

1669                audit\_inode(pathname,nd->path.dentry);

1670                goto ok;

1671        \}

1672

1673        /\* OK, it's O\_CREAT \*/

1674        mutex\_lock(&dir->d\_inode->i\_mutex);

1675

1676        path->dentry = lookup\_hash(nd);

1677        path->mnt = nd->path.mnt;

1678

1679        error = PTR\_ERR(path->dentry);

1680        if (IS\_ERR(path->dentry)) \{

1681                mutex\_unlock(&dir->d\_inode->i\_mutex);

1682                goto exit;

1683        \}

1684

1685        if (IS\_ERR(nd->intent.open.file)) \{

1686                error =PTR\_ERR(nd->intent.open.file);

1687                goto exit\_mutex\_unlock;

1688        \}

1689

1690        /\* Negative dentry, just create thefile \*/

1691        if (!path->dentry->d\_inode) \{

1692                /\*

1693                 \* This write is needed toensure that a

1694                 \* ro->rw transition doesnot occur between

1695                 \* the time when the file iscreated and when

1696                 \* a permanent write count istaken through

1697                 \* the 'struct file' innameidata\_to\_filp().

1698                 \*/

1699                error =mnt\_want\_write(nd->path.mnt);

1700                if (error)

1701                        goto exit\_mutex\_unlock;

1702                error =\_\_open\_namei\_create(nd, path, open\_flag, mode);

1703                if (error) \{

1704                        mnt\_drop\_write(nd->path.mnt);

1705                        goto exit;

1706                \}

1707                filp = nameidata\_to\_filp(nd);

1708                mnt\_drop\_write(nd->path.mnt);

1709                if (!IS\_ERR(filp)) \{

1710                        error =ima\_file\_check(filp, acc\_mode);

1711                        if (error) \{

1712                                fput(filp);

1713                                filp =ERR\_PTR(error);

1714                        \}

1715                \}

1716                return filp;

1717        \}

1718

1719        /\*

1720         \* It already exists.

1721         \*/

1722        mutex\_unlock(&dir->d\_inode->i\_mutex);

1723        audit\_inode(pathname,path->dentry);

1724

1725        error = -EEXIST;

1726        if (open\_flag & O\_EXCL)

1727                goto exit\_dput;

1728

1729        if (\_\_follow\_mount(path)) \{

1730                error = -ELOOP;

1731                if (open\_flag &O\_NOFOLLOW)

1732                        goto exit\_dput;

1733        \}

1734

1735        error = -ENOENT;

1736        if (!path->dentry->d\_inode)

1737                goto exit\_dput;

1738

1739        if(path->dentry->d\_inode->i\_op->follow\_link)

1740                return NULL;

1741

1742        path\_to\_nameidata(path, nd);

1743        error = -EISDIR;

1744        if(S\_ISDIR(path->dentry->d\_inode->i\_mode))

1745                goto exit;

1746ok:

1747        filp = finish\_open(nd, open\_flag,acc\_mode);

1748        return filp;

1749

1750exit\_mutex\_unlock:

1751        mutex\_unlock(&dir->d\_inode->i\_mutex);

1752exit\_dput:

1753        path\_put\_conditional(path, nd);

1754exit:

1755        if (!IS\_ERR(nd->intent.open.file))

1756                release\_open\_intent(nd);

1757        path\_put(&nd->path);

1758        return ERR\_PTR(error);

1759\}

\---------------------------------------------------------------------

再对这些参数进行以下说明，nd指向的nameidata的path中存放的是路径名最后一个分量的父目录的路径path，其last字段中存放的是路径名最后一个分量的名字的信息qstr结构

(1)这个函数首先根据路径名的最后一个分量的名字信息，来采取一些动作。

如果最后一个分量是“..”则调用follow\_dotdot(nd)返回上一级目录，并设置局部变量dir为nd->path.dentry。

若最后一个分量是“.”,则检查nd->path.mnt->mnt\_sb->s\_type->fs\_flags的FS\_REVAL\_DOT，若设置了该标志，则调用目录项的dir->d\_op->d\_revalidate(dir,nd)方法，若该方法失败，则释放先前分配的file结构，减少nd->path的引用计数，并返回错误码\-ESTALE。

若最后一个分量为根目录。若设置了打开标志为O\_CREAT，则释放先前分配的file结构，减少nd->path的引用计数，并返回错误码\-EISDIR。

若为符号链接，则调用finish\_open()来完成最后的打开文件操作，并返回file结构指针filp。finish\_open()函数稍后解释。

这一步中处理那些最后一个分量的路径已经获得并保存在nd->path中或者最后一个分量为符号链接的情况。同时我们也可以看到，是可以直接使用open来打开目录的，但是不能创建目录。

(2)、若路径名的最后一个分量是以“/”结尾（这根据nd->last.name\[nd->last.len\]的值来判断，在link\_path\_walk()函数中求出nd->last值的相关部分可以看出，若已“/”结尾，则nd->last.name\[nd->last.len\]的值正是字符’ /’）的，则检查打开标志是否设置了O\_CREAT，若是则释放先前分配的file结构，减少nd->path的引用计数，并返回错误码\-EISDIR；若没有则，设置nd查找标志nd->flags的LOOKUP\_DIRECTORY和LOOKUP\_FOLLOW位。

(3)、若打开标志没有设置O\_CREAT。则调用do\_lookup(nd, &nd->last, path)来完成最路径名中最后一个分量路径的查找。

若返回错误码，则释放先前分配的file结构，减少nd->path的引用计数，并返回该错误码。

若查找的结果path->dentry->d\_inode为NULL，则调用path\_put\_conditional(path, nd)来释放查找到的path->dentry，若最后一个分量表示的是挂载点则还要释放path->mnt。释放先前分配的file结构，减少nd->path的引用计数，并返回错误码\-ENOENT。

若最后一个分量表示的是符号链接，则返回NULL。

若设置了查找标志的LOOKUP\_DIRECTORY位，则还有判断找到的是否为一个目录（通过检查path->dentry->d\_inode->i\_op->lookup），若不是目录，则调用path\_put\_conditional(path, nd)来释放查找到的path->dentry，若最后一个分量表示的是挂载点则还要释放path->mnt。释放先前分配的file结构，减少nd->path的引用计数，并返回错误码\-ENOTDIR。

调用path\_to\_nameidata(path, nd)将使得nd->path中保存有路径名最后一个分量的路径。完成审计信息记录。

调用finish\_open()来完成最后的打开文件操作，并返回file结构指针filp。finish\_open()函数稍后解释。

(4)、打开标志设置了O\_CREAT，若文件不存在则要创建的情况。首先要对父目录的inode上锁（mutex\_lock(&dir->d\_inode->i\_mutex)），调用lookup\_hash(nd)在目录项缓存中查找或者创建路径名最后一个分量的目录项。其定义为：

\---------------------------------------------------------------------

fs/namei.c

1122static struct dentry \*\_\_lookup\_hash(struct qstr \*name,

1123                struct dentry \*base, structnameidata \*nd)

1124\{

1125        struct dentry \*dentry;

1126        struct inode \*inode;

1127        int err;

1128

1129        inode = base->d\_inode;

1130

1131        /\*

1132         \* See if the low-level filesystemmight want

1133         \* to use its own hash..

1134         \*/

1135        if (base->d\_op &&base->d\_op->d\_hash) \{

1136                err =base->d\_op->d\_hash(base, name);

1137                dentry = ERR\_PTR(err);

1138                if (err < 0)

1139                        goto out;

1140        \}

1141

1142        dentry = \_\_d\_lookup(base, name);

1143

1144        /\* lockess \_\_d\_lookup may fail due toconcurrent d\_move()

1145         \* in some unrelated directory, so trywith d\_lookup

1146         \*/

1147        if (!dentry)

1148                dentry = d\_lookup(base, name);

1149

1150        if (dentry && dentry->d\_op&& dentry->d\_op->d\_revalidate)

1151                dentry = do\_revalidate(dentry,nd);

1152

1153        if (!dentry) \{

1154                struct dentry \*new;

1155

1156                /\* Don't create child dentryfor a dead directory. \*/

1157                dentry = ERR\_PTR(-ENOENT);

1158                if (IS\_DEADDIR(inode))

1159                        goto out;

1160

1161                new = d\_alloc(base, name);

1162                dentry = ERR\_PTR(-ENOMEM);

1163                if (!new)

1164                        goto out;

1165                dentry =inode->i\_op->lookup(inode, new, nd);

1166                if (!dentry)

1167                        dentry = new;

1168                else

1169                        dput(new);

1170        \}

1171out:

1172        return dentry;

1173\}

1175/\*

1176 \* Restricted form of lookup. Doesn't followlinks, single-component only,

1177 \* needs parent already locked. Doesn't followmounts.

1178 \* SMP-safe.

1179 \*/

1180static struct dentry \*lookup\_hash(struct nameidata \*nd)

1181\{

1182        int err;

1183

1184        err =exec\_permission(nd->path.dentry->d\_inode);

1185        if (err)

1186                return ERR\_PTR(err);

1187        return \_\_lookup\_hash(&nd->last,nd->path.dentry, nd);

1188\}

\---------------------------------------------------------------------

lookup\_hash(nd)函数当在目录项缓存中没有找到要找的目录项时，会分配目录项，并且会调用父目录的inode->i\_op->lookup(inode, new, nd)方法来创建所要查找的文件的inode等信息，并设置目录项的适当字段。但是在目录中没有所要查找的文件时，lookup(inode,new, nd)方法并不返回错误。

lookup\_hash(nd)函数返回的结果被赋给path->dentry。path用来存放路径名最后一个分量的path结构。

初始化path->mnt为父目录的vfsmount对象。

(5)、检查path->dentry是否是一个错误码的指针形式，若是则对父目录的inode解锁（mutex\_unlock(&dir->d\_inode->i\_mutex)），减少nd->path的引用计数，并返回该错误码。

(6)、检查nd->intent.open.file是否包含一个错误码，若是则首先对父目录的inode解锁，接着调用path\_put\_conditional(path, nd)来释放由lookup\_hash(nd)查找到或创建的path->dentry，若最后一个分量表示的是挂载点则还要释放path->mnt。释放先前分配的file结构，减少nd->path的引用计数，并返回错误码\-ENOTDIR。

(7)、检查path->dentry->d\_inode是否为NULL，若是，则说明要创建一个文件。

首先调用mnt\_want\_write(nd->path.mnt)，来确保在创建文件和在nameidata\_to\_filp()中通过struct file取得固定的写计数之间不会发生ro -> rw的转换。这个函数本质上增加vfsmount对象的写着计数器mnt->mnt\_writers。

调用\_\_open\_namei\_create(nd, path, open\_flag, mode)函数来创建一个文件，这个函数定义为：

\---------------------------------------------------------------------

fs/namei.c

1502/\*

1503 \* Be careful about ever adding any morecallers of this

1504 \* function. Its flags must be in the namei format, not

1505 \* what get passed to sys\_open().

1506 \*/

1507static int \_\_open\_namei\_create(struct nameidata \*nd, struct path \*path,

1508                                int open\_flag,int mode)

1509\{

1510        int error;

1511        struct dentry \*dir =nd->path.dentry;

1512

1513        if (!IS\_POSIXACL(dir->d\_inode))

1514                mode &= ~current\_umask();

1515        error =security\_path\_mknod(&nd->path, path->dentry, mode, 0);

1516        if (error)

1517                goto out\_unlock;

1518        error = vfs\_create(dir->d\_inode,path->dentry, mode, nd);

1519out\_unlock:

1520        mutex\_unlock(&dir->d\_inode->i\_mutex);

1521        dput(nd->path.dentry);

1522        nd->path.dentry = path->dentry;

1523        if (error)

1524                return error;

1525        /\* Don't check for write permission,don't truncate \*/

1526        return may\_open(&nd->path, 0,open\_flag & ~O\_TRUNC);

1527\}

\---------------------------------------------------------------------

\_\_open\_namei\_create()函数在执行了访问权限检查后，就调用父目录inode的create方法dir->i\_op->create(dir, dentry,mode, nd)来创建文件。之后，\_\_open\_namei\_create()解除对于父目录inode的锁定，释放父目录目录项，并将路径名最后一个分量目录项path->dentry赋给nd->path.dentry。然后返回对may\_open(&nd->path,0, open\_flag & ~O\_TRUNC)调用的返回值。

调用nameidata\_to\_filp(nd)来将一个nameidata转换为一个打开的filp，这个函数本质上主要调用\_\_dentry\_open(nd->path.dentry,nd->path.mnt, filp,     NULL, cred)来根据当前进程的状态和获得的目录项来设置nd->intent.open.file所指向的file结构的各字段。

调用mnt\_drop\_write(nd->path.mnt)来减少nd->path.mnt写者计数器的值。

返回filp。

(8)、尽管设置了打开标志的O\_CREAT，但是却找到了所需的文件。则首先对父目录inode解锁。检查打开标志是否设置了O\_EXCL，若是，则调用path\_put\_conditional(path, nd)来释放查找到的path->dentry，若最后一个分量表示的是挂载点则还要释放path->mnt。释放先前分配的file结构，减少nd->path的引用计数，并返回错误码\-EEXIST。

调用\_\_follow\_mount(path)找到挂载在本路径上的文件系统，即vfsmount对象的地址和目录项对象地址。

调用finish\_open()来完成打开草走。

(9)、返回filp。

h.若最后一个分量是一个符号链接，则追踪符号链接。

i、返回filp

4、将文件安装在fd数组中。

5、释放路径名所占用的临时内存空间tmp

6 、返回文件描述符fd。  
  
  
 **close系统调用**

close()系统调用

@font-face \{ font-family: "宋体";\}@font-face \{ font-family: "@宋体";\}p.MsoNormal, li.MsoNormal, div.MsoNormal \{ margin: 0cm 0cm 0.0001pt; text-align: justify; font-size: 10.5pt; font-family: "Times New Roman"; \}div.Section1 \{ page: Section1; \}

程序关闭打开的文件使用close()系统调用，它接收的参数为要关闭文件的文件描述符fd。sys\_close()服务例程定义如下：

\---------------------------------------------------------------------

fs/open.c

/\*

\* Careful here! We test whether the filepointer is NULL before

\* releasing the fd. This ensures that oneclone task can't release

\* an fd while another clone is opening it.

\*/

SYSCALL\_DEFINE1(close,unsigned int, fd)

struct file \* filp;

struct files\_struct \*files =current->files;

struct fdtable \*fdt;

int retval;

spin\_lock(&files->file\_lock);

fdt = files\_fdtable(files);

if (fd >= fdt->max\_fds)

goto out\_unlock;

filp = fdt->fd\[fd\];

if (!filp)

goto out\_unlock;

rcu\_assign\_pointer(fdt->fd\[fd\], NULL);

FD\_CLR(fd, fdt->close\_on\_exec);

\_\_put\_unused\_fd(files, fd);

spin\_unlock(&files->file\_lock);

retval = filp\_close(filp, files);

/\* can't restart close syscall because filetable entry was cleared \*/

if (unlikely(retval == -ERESTARTSYS ||

retval == -ERESTARTNOINTR ||

retval == -ERESTARTNOHAND ||

retval == -ERESTART\_RESTARTBLOCK))

retval = -EINTR;

return retval;

out\_unlock:

spin\_unlock(&files->file\_lock);

return -EBADF;

\---------------------------------------------------------------------

sys\_close()服务例程执行下列操作：

1、获得存放在当前进程current->files->fdt->fd\[fd\]中的文件对象，如果它为NULL，则返回\-EBADF

2、把current->files->fdt->fd\[fd\]置为NULL。释放文件描述符fd，这是通过清除current->files->fdt->close\_on\_exec字段相应的位及调用\_\_put\_unused\_fd(files, fd)函数来进行的。\_\_put\_unused\_fd()定义如下：

\---------------------------------------------------------------------

fs/open.c

staticvoid \_\_put\_unused\_fd(struct files\_struct \*files, unsigned int fd)

struct fdtable \*fdt = files\_fdtable(files);

\_\_FD\_CLR(fd, fdt->open\_fds);

if (fd < files->next\_fd)

files->next\_fd = fd;

\---------------------------------------------------------------------

这个函数清除current->files->fdt-> open\_fds字段相应的位。然后对比fd和files->next\_fd，如果前者更小，则更新后者为前者。由此可见files\_struct结构的next\_fd中存放的是文件描述表中可用的最小的文件描述符。这个字段，一来可以为文件描述符的快速分配提供支持，二来则有助于缩小所需搜索的可用的文件描述符的范围。

3、调用filp\_close()，该函数定义如下：

\---------------------------------------------------------------------

fs/open.c

/\*

\* "id" is the POSIX thread ID. Weuse the

\* files pointer for this..

\*/

intfilp\_close(struct file \*filp, fl\_owner\_t id)

int retval = 0;

if (!file\_count(filp)) \{

printk(KERN\_ERR "VFS: Close: filecount is 0\\n");

return 0;

if (filp->f\_op &&filp->f\_op->flush)

retval = filp->f\_op->flush(filp,id);

dnotify\_flush(filp, id);

locks\_remove\_posix(filp, id);

fput(filp);

return retval;

\---------------------------------------------------------------------

该函数执行下列操作：

a.判断文件的引用计数是否为0，若是，则返回0。

b.调用文件操作的flush方法（如果已定义）。

c.释放文件上的任何强制锁。参见后面“文件加锁”部分。

d.调用fput(filp)释放文件对象，该函数定义为：

\---------------------------------------------------------------------

fs/file\_table.c

/\*\_\_fput is called from task context when aio completion releases the last

\* last use of a struct file \*. Do not use otherwise.

\*/

void\_\_fput(struct file \*file)

struct dentry \*dentry =file->f\_path.dentry;

struct vfsmount \*mnt = file->f\_path.mnt;

struct inode \*inode = dentry->d\_inode;

might\_sleep();

fsnotify\_close(file);

/\*

\* Thefunction eventpoll\_release() should be the first called

\* inthe file cleanup chain.

\*/

eventpoll\_release(file);

locks\_remove\_flock(file);

if (unlikely(file->f\_flags & FASYNC))\{

if (file->f\_op &&file->f\_op->fasync)

file->f\_op->fasync(-1, file,0);

if (file->f\_op &&file->f\_op->release)

file->f\_op->release(inode, file);

security\_file\_free(file);

ima\_file\_free(file);

if (unlikely(S\_ISCHR(inode->i\_mode)&& inode->i\_cdev != NULL))

cdev\_put(inode->i\_cdev);

fops\_put(file->f\_op);

put\_pid(file->f\_owner.pid);

file\_kill(file);

if (file->f\_mode & FMODE\_WRITE)

drop\_file\_write\_access(file);

file->f\_path.dentry = NULL;

file->f\_path.mnt = NULL;

file\_free(file);

dput(dentry);

mntput(mnt);

voidfput(struct file \*file)

if(atomic\_long\_dec\_and\_test(&file->f\_count))

\_\_fput(file);

\---------------------------------------------------------------------

在这个函数中，监测与文件有关的file对象、目录项对象及vfsmount对象的引用计数，若引用计数为0，且条件合适，则将它们归还给相应的slab缓存。

4 、返回0,或一个出错码。出错码可由flush方法或文件中的前一个写操作错误产生。

open,close系统调用

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关系统调用

相关系统调用流程

相关操作系统——系统调用

相关 Linux系统调用

相关 mmap系统调用

相关系统调用概念

相关系统调用

相关 execve系统调用

相关 linux系统调用

相关 linux系统调用