`

linux下文件的append是原子的(线程安全的)

 
阅读更多
具体的理由可以参考这个文章:http://www.pagefault.info/?p=139
下面是这个文章的全文:


先来描述一下,write系统调用的大体流程,首先内核会取得对应的文件偏移,然后调用vfs的write操作,而在vfs层的write操作的时候会调用对应文件系统的write方法,而在对应文件系统的write方法中aio_write方法,最终会调用底层驱动。这里有一个需要注意的就是内核在写文件的时候会加一把锁(有些设备不会加锁,比如块设备以及裸设备).这样也就是说一个文件只可能同时只有一个进程在写。而且快设备是不支持append写的。

而这里append的原子操作的实现很简单,由于每次写文件只可能是一个进程操作(计算文件偏移并不包含在锁里面),而append操作是每次写到末尾(其他类型的写是先取得pos才进入临界区,而这个时间内有可能pos已经被其他进程改变,而append的pos的计算是包含在锁里面的),因此自然append就是原子的了.

ok,接下来来看代码。

首先来看write的系统调用,函数很简单,就是取得当前文件的偏移,然后调用vfs的写方法。最后更改文件的偏移。这里要注意,取得文件偏移的方法并没有加锁,也就是说这里存在竞争。

这里有个要注意的就是POS,如果是append写的话,后面的代码会修改这个值,这里先跳过,后面遇到我们会说明。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
        size_t, count)
{
    struct file *file;
    ssize_t ret = -EBADF;
    int fput_needed;

    file = fget_light(fd, &fput_needed);
    if (file) {
//取得文件句柄的偏移
        loff_t pos = file_pos_read(file);
//写文件。传递偏移量。
        ret = vfs_write(file, buf, count, &pos);
//更新偏移
        file_pos_write(file, pos);
        fput_light(file, fput_needed);
    }

    return ret;
}
接下来就是vfs_write,这个函数主要就是进行一些合法性判断,然后调用具体文件系统的write方法,这里要注意,write方法不一定会调用到文件系统的write方法,比如块设备以及裸设备都会调用到blkdev_aio_write。

而file op的初始化在ext3_iget中的,也就是获取超级块的方法,可以看到如果是一般文件,则会被初始化为ext3_file_inode_operations。

1
2
3
4
5
6
7
8
struct inode *ext3_iget(struct super_block *sb, unsigned long ino)
................................................................................
    if (S_ISREG(inode->i_mode)) {
//初始化
        inode->i_op = &ext3_file_inode_operations;
        inode->i_fop = &ext3_file_operations;
        ext3_set_aops(inode);
.................................................
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
.........................................................................
    ret = rw_verify_area(WRITE, file, pos, count);
    if (ret >= 0) {
        count = ret;
//调用具体的文件系统的方法。
        if (file->f_op->write)
            ret = file->f_op->write(file, buf, count, pos);
        else
            ret = do_sync_write(file, buf, count, pos);
..................................................................................
    }

    return ret;
}
我们主要来看ext3的实现,其他的文件系统基本差不多。下面就是ext3文件系统对应回调操作函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
const struct file_operations ext3_file_operations = {
    .llseek     = generic_file_llseek,
//主要是下面4个
    .read       = do_sync_read,
    .write      = do_sync_write,
    .aio_read   = generic_file_aio_read,
    .aio_write  = generic_file_aio_write,
    .unlocked_ioctl = ext3_ioctl,
#ifdef CONFIG_COMPAT
    .compat_ioctl   = ext3_compat_ioctl,
#endif
    .mmap       = generic_file_mmap,
    .open       = dquot_file_open,
    .release    = ext3_release_file,
    .fsync      = ext3_sync_file,
    .splice_read    = generic_file_splice_read,
    .splice_write   = generic_file_splice_write,
};
可以看到它的write方法就是do_sync_write,在do_sync_write中会调用它自己的aio_write方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
{
...............................................
//如果不是块设备才进入下面的处理
    if (!isblk) {
        /* FIXME: this is for backwards compatibility with 2.4 */
//调用i_size_read得到文件大小,从而定位append的位置。
        if (file->f_flags & O_APPEND)
                        *pos = i_size_read(inode);

        if (limit != RLIM_INFINITY) {
            if (*pos >= limit) {
                send_sig(SIGXFSZ, current, 0);
                return -EFBIG;
            }
            if (*count > limit - (typeof(limit))*pos) {
                *count = limit - (typeof(limit))*pos;
            }
        }
    }
...................................................
    return ret;
}
因此可以看到最关键的操作都是放在aio_write中,也就是generic_file_aio_write,这个函数我们可以看到在调用具体的实现__generic_file_aio_write之前会加一把锁(i_mutex),这样就保证了一个文件同时只会有一个进程来写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
ssize_t generic_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
        unsigned long nr_segs, loff_t pos)
{
    struct file *file = iocb->ki_filp;
    struct inode *inode = file->f_mapping->host;
    ssize_t ret;

    BUG_ON(iocb->ki_pos != pos);
//加锁
    mutex_lock(&inode->i_mutex);
//调用具体的实现
    ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
//释放锁
    mutex_unlock(&inode->i_mutex);

    if (ret > 0 || ret == -EIOCBQUEUED) {
        ssize_t err;

        err = generic_write_sync(file, pos, ret);
        if (err < 0 && ret > 0)
            ret = err;
    }
    return ret;
}
上面可以看到先加锁然后调用__generic_file_aio_write,而对应的blkdev_aio_write则是直接调用__generic_file_aio_write,也就是不用加锁,下面就是内核里面的注释:

1
2
* It expects i_mutex to be grabbed unless we work on a block device or similar
* object which does not need locking at all.
然后来看__generic_file_aio_write的实现,这里它调用了generic_write_checks,这个函数主要用来执行写之前的一些检测。

1
2
3
4
5
6
7
8
ssize_t __generic_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
                 unsigned long nr_segs, loff_t *ppos)
{
...................................................................

    err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
......................................................................
}
然后是generic_write_checks,这个函数就是做一些检测,并且APPEND写的原子性也是由这个函数进行控制的。

这里会修改对应的pos,调用i_size_read来得到文件的大小,从而进行append操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
inline int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk)
{
    struct inode *inode = file->f_mapping->host;
    unsigned long limit = rlimit(RLIMIT_FSIZE);

        if (unlikely(*pos < 0))
                return -EINVAL;

    if (!isblk) {
        /* FIXME: this is for backwards compatibility with 2.4 */
//如果是append操作,则调用i_size_read得到文件大小,然后得到文件该写的位置,这里更改了pos的值.
        if (file->f_flags & O_APPEND)
//更改pos
                        *pos = i_size_read(inode);

        if (limit != RLIM_INFINITY) {
            if (*pos >= limit) {
                send_sig(SIGXFSZ, current, 0);
                return -EFBIG;
            }
            if (*count > limit - (typeof(limit))*pos) {
                *count = limit - (typeof(limit))*pos;
            }
        }
    }
.............................................................
}
分享到:
评论

相关推荐

    Redis的Linux版本2.8.13

    综上所述,Redis 2.8.13是Linux环境下的一款强大数据库,它的高性能、丰富的数据结构和灵活的持久化策略使其成为许多开发者和企业的首选。通过下载并解压提供的"redis-2.8.13"压缩包,用户可以开始在自己的Linux环境...

    linux redis5 .zip

    在Linux环境下使用Redis 5.0.0版本,你将能够利用其强大的性能和丰富的数据结构来提升应用程序的效率。以下是一些关于Linux Redis 5.0.0的重要知识点: 1. **Redis的数据类型**: - 字符串(Strings):基本的键值对...

    redis-windows-7.0.4.tar.gz

    标题中的"redis-windows-7.0.4.tar.gz"表明这是一个针对Windows平台的Redis版本,版本号为7.0.4,其文件格式为tar.gz,这是一种常见的在Linux/Unix环境中打包和压缩文件的方式。 在Windows环境下安装Redis,首先...

    redis-6.0.4解压到下一层即可.zip

    本压缩包“redis-6.0.4解压到下一层即可.zip”包含了Redis 6.0.4版本的Linux版安装包,即“redis-6.0.4.tar”,适用于在Linux环境下部署Redis服务。 Redis 6.0.4是Redis的一个稳定版本,相较于之前的版本,它引入了...

    redis3.0 windows64位

    为了启动Redis服务,你需要运行`redis-server.exe`,并根据需要调整配置文件以满足特定的系统需求和安全要求。如果要在Windows上作为服务运行Redis,还需要进行相应的服务注册步骤。此外,了解如何备份和恢复数据、...

    redis-windows-2.8.rar

    - 由于Windows的线程模型与内存管理,性能可能低于Linux。 - 可通过调整配置文件优化性能,如增加最大文件描述符数量。 - 注意Windows防火墙设置,确保Redis服务器对外服务。 6. **压缩包中的意外文件"apache-...

    redis3.0.501

    在Windows环境下,Redis的安装和使用有时会与Linux等其他系统有所不同,但同样提供了高效的服务。 描述中提到的是"windows版,包含管理工具,开发时打开即用",这意味着这个压缩包不仅包含了Redis服务器本身,还...

    Redis-x64-5.0.14.1

    在 Windows 环境下部署 Redis,需要注意与 Linux 环境的差异,比如 Windows 版本可能不支持某些特定功能或性能略逊一筹。在使用 Redis 的过程中,定期备份、监控资源使用情况以及及时更新至最新稳定版本是保持系统...

    redis-2.6.9

    在Linux环境下,解压`redis-2.6.9.tar.gz`文件后,通常需要通过编译源代码来安装Redis,步骤包括`tar -zxvf`解压,`cd`进入目录,`make`编译,然后`make install`安装。安装完成后,可以通过`redis-server`启动Redis...

    Redis-win-x64-3.2.100.rar

    这个版本是Redis 3.2.100,可能包含了相应的编译和配置文件,以及必要的依赖库,使得用户可以在Windows环境下运行Redis服务器。 描述中的“Redis项目不正式支持Windows”意味着在Windows上运行Redis可能没有在Linux...

    Redis-5.0.10.rar

    需要注意的是,由于Redis默认是单线程模型,所以在Windows这种多线程操作系统上可能不如在Linux下表现优秀。若需提升性能,可以考虑使用哨兵(Sentinel)系统实现高可用性集群,或使用Cluster进行分布式部署。 总结...

    redis-windows-7.2.1.zip

    在Windows环境中使用Redis时,可能需要考虑与Linux环境的不同之处,如Windows的文件权限和守护进程管理。此外,由于Redis是单线程模型,所以如果需要处理高并发,可以考虑启动多个实例或者使用哨兵(Sentinel)系统...

    Java面试问题 TXT格式

    - **原子类**:如AtomicInteger等,提供了线程安全的操作。 - **并发工具类**:如Semaphore、CountDownLatch、CyclicBarrier等,用于协调线程间的执行顺序。 #### 6. 多线程中死锁的概念 死锁是指两个或多个线程在...

    redis3.0-windows

    在Windows上运行Redis可能会遇到与Unix/Linux环境不同的问题,比如权限和线程模型,因此需要仔细阅读文档和社区资源来解决问题。同时,由于Redis原生支持Unix信号,Windows用户可能需要使用其他方式来实现类似功能,...

    Redis源码解读与项目精品设计实战

    对于Redis的安装,不论是Linux系统还是Windows系统都有对应的安装步骤,而且如果在Windows系统上安装Redis,可以通过安装msi文件或者使用Redis on Windows服务,或者直接使用云服务器的Linux环境。 整个课程不仅仅...

    redis for windows_3.0

    "redis for windows_3.0"是Redis官方针对Windows平台发布的版本,它确保了Redis在Windows操作系统上的稳定运行,同时也保持了与Linux版本类似的性能。 1. 安装与配置: - Redis for Windows通常以zip文件形式提供...

    redis-6.2.6.zip

    在Windows环境下,由于Redis原生为Linux系统设计,可能会遇到一些兼容性问题,如文件权限、线程调度等。不过,通过社区的努力,这些问题在6.2.6版本中已得到很大程度的解决。 Redis在实际应用中的使用场景: 1. ...

    JAVA面试题.zip

    - 持久化:RDB(快照)、AOF(Append Only File)。 - 主从复制:数据同步、故障转移。 - 事务:多条命令原子执行。 - 模式匹配:KEYS、SCAN命令。 - 缓存策略:LRU(最近最少使用)、TTL(生存时间)。 - 发布订阅...

    redis技术实践

    这些数据结构的操作几乎都是原子性的,确保了在多线程环境中的一致性和安全性。此外,Redis还提供了持久化机制来保证数据的安全性,支持网络通信,并为多种编程语言提供了API。 **1.1 支持的数据类型** - **String...

    redis-6.2.12.tar.gz

    在 Linux 或类 Unix 系统中,可以使用 `tar` 命令解压并提取这个文件。 在 Redis 的 6.2.12 版本中,可能包含以下关键知识点: 1. **数据类型**:Redis 支持五种基本数据类型,包括字符串(String)、哈希(Hash)...

Global site tag (gtag.js) - Google Analytics