Linux Programming 学习笔记：File Locking

什么时候能提桶跑路啊

已于 2022-08-01 14:37:06 修改

阅读量282

点赞数

分类专栏： LinuxProgramming 文章标签： linux unix go 系统架构

于 2022-07-29 11:22:46 首次发布

本文链接：https://blog.csdn.net/weixin_35983774/article/details/126050686

版权

LinuxProgramming 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Advisory lock vs Mandatory lock

建议锁和强制锁。

Advisory lock
- 建议性锁并不从内核限制程序访问文件，而是依赖各个合作进程(cooperating process)之间遵循相应的规则。
- 这意味着进程可以自由地忽略 fcntl()（或flock()）的使用，而只需对文件执行 I/O。
Mandatory lock
- 强制内核检查每次open, read, 和 write操作，保证调用进程没有违反对正在访问的文件的锁。

Advisory mode locking is sometimes referred to as discretionary locking, while mandatory locking is sometimes referred to as enforcement-mode locking. SUSv3 doesn’t specify mandatory locking, but it is available (with some variation in the details) on most modern UNIX implementations.

本文介绍flock()，fcntl()。

flock(), which places locks on entire files; and
fcntl(), which places locks on regions of a file.

flock和fcntl在内核中都用struct file_lock实现。其主要差别就在于owner的不同。
如果lock的owner相同，conflict的检测就会跳过，即相同owner的lock可以递归申请。
flock锁的粒度为整个文件。fcntl提供了字节范围粒度的lock，即 byte-range locking。

Flock

flock(2) - Linux man page
在这里插入图片描述

Values for operation:
operation表明锁的类型，需要指明LOCK_SH, LOCK_EX, 和 LOCK_UN中的其中一个。
并且如果｜LOCK_NB，那么 flock() 不会被阻塞，而是返回error：EWOULDBLOCK。

Value	Description
LOCK_SH	对 fd 引用的文件加共享锁 shared lock
LOCK_EX	对 fd 引用的文件加排他锁 exclusive lock
LOCK_UN	对 fd 引用的文件解锁
LOCK_NB	非阻塞的锁请求

Capability of flock() locking types :

多个进程可以同时对一个文件持有shared lock，只有一个进程可以对一个文件持有exclusive lock（其他进程不能再持有shared lock或是exclusive lock）。
注意，无论文件的访问模式（read, write, or read-write）如何，进程都可以放置共享或排他锁。
通过再次调用flock() ，可以将现有的共享锁转换为排他锁（反之亦然）。如果另一个进程持有文件上的共享锁，则将共享锁转换为排他锁将阻塞，除非还指定了 LOCK_NB。

Semantics

flock对整个文件上锁。flock的owner是内核态open fd，而不是用户态fd或者inode。
在这里插入图片描述

A file lock obtained via flock() is associated with the open file
description , rather than the file descriptor or the file (i-node)
itself.

若调用dup(),dup2(), or fcntl() F_DUPFD 复制fd，新的fd指向同一个内核态中的open fd，故指向同一个的file lock。（以下以go语言做示例）

fd, _ := syscall.Open("lockfile", syscall.O_RDWR, 0644)
newfd, _ := syscall.Dup(fd)
if err = unix.Flock(fd, unix.LOCK_EX|unix.LOCK_NB); err != nil {
  log.Fatal(err)
}
if err = unix.Flock(newfd, unix.LOCK_EX|unix.LOCK_NB); err != nil {
  log.Fatal(err)
}

fd和newfd指向同一个open fd，对fd上锁，并不影响通过newfd上锁。

若调用open()获取相同文件的新fd，fd1,fd2对应内核态中不同的open fd。

fd1, _ := syscall.Open("lockfile", syscall.O_RDWR, 0644)
fd2, _ := syscall.Open("lockfile", syscall.O_RDWR, 0644)
if err = unix.Flock(fd1, unix.LOCK_EX|unix.LOCK_NB); err != nil {
  log.Fatal(err)
}
if err = unix.Flock(fd2, unix.LOCK_UN|unix.LOCK_NB); err != nil {
  log.Fatal(err)              /*return: resource temporarily unavailable, Locked out by lock on 'fd1'*/
}

对fd2上锁被阻塞。

Limitation

锁的粒度为整个文件。
只能为advisory locks
Many NFS implementations don’t recognize locks granted by flock().

Fcntl

fcntl(2) - Linux man page
在这里插入图片描述

flock structure

struct flock {
    short l_type; /* Lock type: F_RDLCK, F_WRLCK, F_UNLCK */
    short l_whence; /* How to interpret 'l_start': SEEK_SET, SEEK_CUR, SEEK_END */
	off_t l_start;/* Offset where the lock begins */
	off_t l_len;/* Number of bytes to lock; 0 means "until EOF" */
	pid_t l_pid; /* Process preventing our lock (F_GETLK only) */ 
};