flock
struct flock* lock);
const struct flock* lock, bool wait);
const struct flock* lock);
extern int flock(int fd, int op);
struct flock *);
int (*flock) (const char *, struct fuse_file_info *, int op);
struct fuse_file_info *fi, int cmd, struct flock *lock);
void (*flock) (fuse_req_t req, fuse_ino_t ino,
int fuse_reply_lock(fuse_req_t req, const struct flock *lock);
struct fuse_file_info *fi, struct flock *lock);
struct flock *lock, int sleep);
LockInfo::operator==(const struct flock& lock) const
bool operator==(const struct flock& lock) const;
Inode::TestLock(OpenFileCookie* cookie, struct flock* lock)
Inode::AcquireLock(OpenFileCookie* cookie, const struct flock* lock,
Inode::ReleaseLock(OpenFileCookie* cookie, const struct flock* lock)
struct flock* lock);
const struct flock* lock, bool wait);
const struct flock* lock);
struct flock* lock)
const struct flock* lock, bool wait)
const struct flock* lock)
struct flock flk;
struct flock flk;
int cmd, struct flock* lock)
format_pointer(Context &context, flock *lock)
POINTER_TYPE(flock_ptr, flock);
struct flock;
DEFINE_FACTORY(flock_ptr, flock *);
FCNTL_INFO_ENTRY_TYPE(F_GETLK, struct flock*),
FCNTL_INFO_ENTRY_TYPE(F_SETLK, struct flock*),
FCNTL_INFO_ENTRY_TYPE(F_SETLKW, struct flock*),
struct flock lock;
if (flock(pfh->pf_fd, LOCK_UN) == -1) {
struct flock fl;
advisory_lock_intersects(struct advisory_lock* lock, struct flock* flock)
if (flock == NULL)
return lock->start <= flock->l_start - 1 + flock->l_len
&& lock->end >= flock->l_start;
test_advisory_lock(struct vnode* vnode, struct flock* flock)
flock->l_type = F_UNLCK;
if (lock->team != team && advisory_lock_intersects(lock, flock)) {
if (flock->l_type != F_RDLCK || !lock->shared) {
flock->l_type = lock->shared ? F_RDLCK : F_WRLCK;
flock->l_whence = SEEK_SET;
flock->l_start = lock->start;
flock->l_len = lock->end - lock->start + 1;
flock->l_pid = lock->team;
struct file_descriptor* descriptor, struct flock* flock)
FUNCTION(("release_advisory_lock(vnode = %p, flock = %p)\n", vnode, flock));
&& advisory_lock_intersects(lock, flock)) {
if (flock != NULL) {
startsBefore = lock->start < flock->l_start;
endsBeyond = lock->end > flock->l_start - 1 + flock->l_len;
lock->end = flock->l_start - 1;
lock->start = flock->l_start + flock->l_len;
lock->end = flock->l_start - 1;
secondLock->start = flock->l_start + flock->l_len;
struct file_descriptor* descriptor, struct flock* flock, bool wait)
vnode, flock, wait ? "yes" : "no"));
bool shared = flock->l_type == F_RDLCK;
&& advisory_lock_intersects(lock, flock)) {
lock->start = flock->l_start;
lock->end = flock->l_start - 1 + flock->l_len;
normalize_flock(struct file_descriptor* descriptor, struct flock* flock)
switch (flock->l_whence) {
flock->l_start += descriptor->pos;
flock->l_start += stat.st_size;
if (flock->l_start < 0)
flock->l_start = 0;
if (flock->l_len == 0)
flock->l_len = OFF_MAX;
if (flock->l_start > 0 && OFF_MAX - flock->l_start < flock->l_len)
flock->l_len = OFF_MAX - flock->l_start;
if (flock->l_len < 0) {
flock->l_start += flock->l_len;
flock->l_len = -flock->l_len;
struct flock flock;
memcpy(&flock, (struct flock*)argument, sizeof(struct flock));
else if (user_memcpy(&flock, (struct flock*)argument,
sizeof(struct flock)) != B_OK)
struct flock normalizedLock;
memcpy(&normalizedLock, &flock, sizeof(struct flock));
flock.l_type = F_UNLCK;
memcpy((struct flock*)argument, &flock,
sizeof(struct flock));
status = user_memcpy((struct flock*)argument,
&flock, sizeof(struct flock));
memcpy((struct flock*)argument,
&normalizedLock, sizeof(struct flock));
status = user_memcpy((struct flock*)argument,
&normalizedLock, sizeof(struct flock));
status = normalize_flock(descriptor.Get(), &flock);
} else if (flock.l_type == F_UNLCK) {
&flock);
&flock);
&& flock.l_type == F_WRLCK)
&& flock.l_type == F_RDLCK))
descriptor->cookie, &flock, op == F_SETLKW);
&flock, op == F_SETLKW);
struct flock flock;
flock.l_start = 0;
flock.l_len = OFF_MAX;
flock.l_whence = 0;
flock.l_type = (operation & LOCK_SH) != 0 ? F_RDLCK : F_WRLCK;
status = FS_CALL(vnode, release_lock, descriptor->cookie, &flock);
status = release_advisory_lock(vnode, NULL, descriptor.Get(), &flock);
status = FS_CALL(vnode, acquire_lock, descriptor->cookie, &flock,
status = acquire_advisory_lock(vnode, NULL, descriptor.Get(), &flock,
struct flock fileLock;
struct flock flock;
flock.l_type = type;
flock.l_whence = SEEK_SET;
flock.l_start = start;
flock.l_len = length;
if (fcntl(fd, F_SETLK, &flock) != 0) {
flock.l_type = F_WRLCK;
flock.l_start = 100;
flock.l_len = 42;
if (fcntl(fd, F_SETLK, &flock) == -1) {
flock.l_start = 200;
if (fcntl(fd, F_SETLK, &flock) == -1) {
flock.l_start = 80;
if (fcntl(fd, F_SETLK, &flock) == 0) {
flock.l_type = F_UNLCK;
flock.l_start = 100;
if (fcntl(fd, F_SETLK, &flock) == -1) {
flock.l_type = F_WRLCK;
flock.l_start = 80;
if (fcntl(fd, F_SETLK, &flock) == -1) {
flock.l_type = F_UNLCK;
flock.l_start = 200;
if (fcntl(fd, F_SETLK, &flock) == -1) {
struct flock flock = {
if (fcntl(fd, F_SETLK, &flock) == 0) {
if (fcntl(fd, F_SETLKW, &flock) == -1) {
flock.l_type = F_UNLCK;
if (fcntl(fd, F_SETLK, &flock) == -1) {
struct flock flock = {
if (fcntl(fd, F_SETLK, &flock) == 0) {
flock.l_type = F_RDLCK;
if (fcntl(fd, F_SETLK, &flock) == -1) {