arch/arm/kernel/sys_oabi-compat.c

239

struct flock64 flock;

arch/arm/kernel/sys_oabi-compat.c

251

err = get_oabi_flock(&flock, argp);

arch/arm/kernel/sys_oabi-compat.c

254

err = fcntl_getlk64(fd_file(f), cmd, &flock);

arch/arm/kernel/sys_oabi-compat.c

256

err = put_oabi_flock(&flock, argp);

arch/arm/kernel/sys_oabi-compat.c

265

err = get_oabi_flock(&flock, argp);

arch/arm/kernel/sys_oabi-compat.c

268

err = fcntl_setlk64(fd, fd_file(f), cmd, &flock);

arch/um/os-Linux/file.c

577

struct flock lock = ((struct flock) { .l_type = type,

drivers/nvme/target/fc.c

2317

spin_lock_irqsave(&fod->flock, flags);

drivers/nvme/target/fc.c

2319

spin_unlock_irqrestore(&fod->flock, flags);

drivers/nvme/target/fc.c

2360

spin_lock_irqsave(&fod->flock, flags);

drivers/nvme/target/fc.c

2363

spin_unlock_irqrestore(&fod->flock, flags);

drivers/nvme/target/fc.c

2372

spin_lock_irqsave(&fod->flock, flags);

drivers/nvme/target/fc.c

2374

spin_unlock_irqrestore(&fod->flock, flags);

drivers/nvme/target/fc.c

2382

spin_lock_irqsave(&fod->flock, flags);

drivers/nvme/target/fc.c

2384

spin_unlock_irqrestore(&fod->flock, flags);

drivers/nvme/target/fc.c

2463

spin_lock_irqsave(&fod->flock, flags);

drivers/nvme/target/fc.c

2465

spin_unlock_irqrestore(&fod->flock, flags);

drivers/nvme/target/fc.c

2788

spin_lock(&fod->flock);

drivers/nvme/target/fc.c

2791

spin_unlock(&fod->flock);

drivers/nvme/target/fc.c

633

spin_lock_init(&fod->flock);

drivers/nvme/target/fc.c

87

spinlock_t flock;

drivers/nvme/target/fc.c

882

spin_lock(&fod->flock);

drivers/nvme/target/fc.c

891

spin_unlock(&fod->flock);

drivers/nvme/target/fc.c

895

spin_unlock(&fod->flock);

fs/9p/vfs_file.c

125

struct p9_flock flock;

fs/9p/vfs_file.c

141

memset(&flock, 0, sizeof(flock));

fs/9p/vfs_file.c

145

flock.type = P9_LOCK_TYPE_RDLCK;

fs/9p/vfs_file.c

148

flock.type = P9_LOCK_TYPE_WRLCK;

fs/9p/vfs_file.c

151

flock.type = P9_LOCK_TYPE_UNLCK;

fs/9p/vfs_file.c

154

flock.start = fl->fl_start;

fs/9p/vfs_file.c

156

flock.length = 0;

fs/9p/vfs_file.c

158

flock.length = fl->fl_end - fl->fl_start + 1;

fs/9p/vfs_file.c

159

flock.proc_id = fl->c.flc_pid;

fs/9p/vfs_file.c

160

flock.client_id = fid->clnt->name;

fs/9p/vfs_file.c

162

flock.flags = P9_LOCK_FLAGS_BLOCK;

fs/9p/vfs_file.c

171

res = p9_client_lock_dotl(fid, &flock, &status);

fs/9p/vfs_file.c

186

if (flock.client_id != fid->clnt->name) {

fs/9p/vfs_file.c

187

kfree(flock.client_id);

fs/9p/vfs_file.c

188

flock.client_id = fid->clnt->name;

fs/9p/vfs_file.c

222

if (flock.client_id != fid->clnt->name)

fs/9p/vfs_file.c

223

kfree(flock.client_id);

fs/9p/vfs_file.c

529

.flock = v9fs_file_flock_dotl,

fs/afs/file.c

45

.flock = afs_flock,

fs/ceph/dir.c

2236

.flock = ceph_flock,

fs/ceph/file.c

3253

.flock = ceph_flock,

fs/fcntl.c

450

struct flock flock;

fs/fcntl.c

484

if (copy_from_user(&flock, argp, sizeof(flock)))

fs/fcntl.c

486

err = fcntl_getlk(filp, cmd, &flock);

fs/fcntl.c

487

if (!err && copy_to_user(argp, &flock, sizeof(flock)))

fs/fcntl.c

498

if (copy_from_user(&flock, argp, sizeof(flock)))

fs/fcntl.c

500

err = fcntl_setlk(fd, filp, cmd, &flock);

fs/fcntl.c

613

struct flock64 flock;

fs/fcntl.c

632

if (copy_from_user(&flock, argp, sizeof(flock)))

fs/fcntl.c

634

err = fcntl_getlk64(fd_file(f), cmd, &flock);

fs/fcntl.c

635

if (!err && copy_to_user(argp, &flock, sizeof(flock)))

fs/fcntl.c

643

if (copy_from_user(&flock, argp, sizeof(flock)))

fs/fcntl.c

645

err = fcntl_setlk64(fd, fd_file(f), cmd, &flock);

fs/fcntl.c

664

static int get_compat_flock(struct flock *kfl, const struct compat_flock __user *ufl)

fs/fcntl.c

674

static int get_compat_flock64(struct flock *kfl, const struct compat_flock64 __user *ufl)

fs/fcntl.c

684

static int put_compat_flock(const struct flock *kfl, struct compat_flock __user *ufl)

fs/fcntl.c

695

static int put_compat_flock64(const struct flock *kfl, struct compat_flock64 __user *ufl)

fs/fcntl.c

734

static int fixup_compat_flock(struct flock *flock)

fs/fcntl.c

736

if (flock->l_start > COMPAT_OFF_T_MAX)

fs/fcntl.c

738

if (flock->l_len > COMPAT_OFF_T_MAX)

fs/fcntl.c

739

flock->l_len = COMPAT_OFF_T_MAX;

fs/fcntl.c

747

struct flock flock;

fs/fcntl.c

764

err = get_compat_flock(&flock, compat_ptr(arg));

fs/fcntl.c

767

err = fcntl_getlk(fd_file(f), convert_fcntl_cmd(cmd), &flock);

fs/fcntl.c

770

err = fixup_compat_flock(&flock);

fs/fcntl.c

772

err = put_compat_flock(&flock, compat_ptr(arg));

fs/fcntl.c

776

err = get_compat_flock64(&flock, compat_ptr(arg));

fs/fcntl.c

779

err = fcntl_getlk(fd_file(f), convert_fcntl_cmd(cmd), &flock);

fs/fcntl.c

781

err = put_compat_flock64(&flock, compat_ptr(arg));

fs/fcntl.c

785

err = get_compat_flock(&flock, compat_ptr(arg));

fs/fcntl.c

788

err = fcntl_setlk(fd, fd_file(f), convert_fcntl_cmd(cmd), &flock);

fs/fcntl.c

794

err = get_compat_flock64(&flock, compat_ptr(arg));

fs/fcntl.c

797

err = fcntl_setlk(fd, fd_file(f), convert_fcntl_cmd(cmd), &flock);

fs/fuse/file.c

2492

int flock, struct fuse_lk_in *inarg)

fs/fuse/file.c

2505

if (flock)

fs/fuse/file.c

2534

static int fuse_setlk(struct file *file, struct file_lock *fl, int flock)

fs/fuse/file.c

2550

fuse_lk_fill(&args, file, fl, opcode, pid_nr, flock, &inarg);

fs/fuse/file.c

2597

ff->flock = true;

fs/fuse/file.c

3090

.flock = fuse_file_flock,

fs/fuse/file.c

362

if (ra && ff->flock) {

fs/fuse/fuse_i.h

324

bool flock:1;

fs/gfs2/file.c

1602

.flock = gfs2_flock,

fs/gfs2/file.c

1617

.flock = gfs2_flock,

fs/locks.c

2280

SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)

fs/locks.c

2319

if (fd_file(f)->f_op->flock)

fs/locks.c

2320

error = fd_file(f)->f_op->flock(fd_file(f),

fs/locks.c

2401

static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl)

fs/locks.c

2403

flock->l_pid = locks_translate_pid(&fl->c, task_active_pid_ns(current));

fs/locks.c

2414

flock->l_start = fl->fl_start;

fs/locks.c

2415

flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :

fs/locks.c

2417

flock->l_whence = 0;

fs/locks.c

2418

flock->l_type = fl->c.flc_type;

fs/locks.c

2423

static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl)

fs/locks.c

2425

flock->l_pid = locks_translate_pid(&fl->c, task_active_pid_ns(current));

fs/locks.c

2426

flock->l_start = fl->fl_start;

fs/locks.c

2427

flock->l_len = fl->fl_end == OFFSET_MAX ? 0 :

fs/locks.c

2429

flock->l_whence = 0;

fs/locks.c

2430

flock->l_type = fl->c.flc_type;

fs/locks.c

2437

int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock *flock)

fs/locks.c

2446

if (cmd != F_OFD_GETLK && flock->l_type != F_RDLCK

fs/locks.c

2447

&& flock->l_type != F_WRLCK)

fs/locks.c

2450

error = flock_to_posix_lock(filp, fl, flock);

fs/locks.c

2456

if (flock->l_pid != 0)

fs/locks.c

2467

flock->l_type = fl->c.flc_type;

fs/locks.c

2469

error = posix_lock_to_flock(flock, fl);

fs/locks.c

2566

struct flock *flock)

fs/locks.c

2576

error = flock_to_posix_lock(filp, file_lock, flock);

fs/locks.c

2591

if (flock->l_pid != 0)

fs/locks.c

2600

if (flock->l_pid != 0)

fs/locks.c

2645

int fcntl_getlk64(struct file *filp, unsigned int cmd, struct flock64 *flock)

fs/locks.c

2655

if (cmd != F_OFD_GETLK && flock->l_type != F_RDLCK

fs/locks.c

2656

&& flock->l_type != F_WRLCK)

fs/locks.c

2659

error = flock64_to_posix_lock(filp, fl, flock);

fs/locks.c

2665

if (flock->l_pid != 0)

fs/locks.c

2676

flock->l_type = fl->c.flc_type;

fs/locks.c

2678

posix_lock_to_flock64(flock, fl);

fs/locks.c

2689

struct flock64 *flock)

fs/locks.c

2698

error = flock64_to_posix_lock(filp, file_lock, flock);

fs/locks.c

2713

if (flock->l_pid != 0)

fs/locks.c

2722

if (flock->l_pid != 0)

fs/locks.c

2816

if (filp->f_op->flock)

fs/locks.c

2817

filp->f_op->flock(filp, F_SETLKW, &fl);

fs/locks.c

561

struct flock *l)

fs/nfs/file.c

976

.flock = nfs_flock,

fs/nfs/nfs4file.c

445

.flock = nfs_flock,

fs/ocfs2/file.c

2826

.flock = ocfs2_flock,

fs/ocfs2/file.c

2848

.flock = ocfs2_flock,

fs/ocfs2/file.c

2877

.flock = ocfs2_flock,

fs/ocfs2/file.c

2896

.flock = ocfs2_flock,

fs/smb/client/cifsfs.c

1661

.flock = cifs_flock,

fs/smb/client/cifsfs.c

1681

.flock = cifs_flock,

fs/smb/client/cifsfs.c

1701

.flock = cifs_flock,

fs/smb/client/cifsfs.h

113

int cifs_lock(struct file *file, int cmd, struct file_lock *flock);

fs/smb/client/cifsproto.h

165

int cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,

fs/smb/client/file.c

1700

__u8 type, struct file_lock *flock)

fs/smb/client/file.c

1711

flock->c.flc_flags, &conf_lock,

fs/smb/client/file.c

1714

flock->fl_start = conf_lock->offset;

fs/smb/client/file.c

1715

flock->fl_end = conf_lock->offset + conf_lock->length - 1;

fs/smb/client/file.c

1716

flock->c.flc_pid = conf_lock->pid;

fs/smb/client/file.c

1718

flock->c.flc_type = F_RDLCK;

fs/smb/client/file.c

1720

flock->c.flc_type = F_WRLCK;

fs/smb/client/file.c

1724

flock->c.flc_type = F_UNLCK;

fs/smb/client/file.c

1802

cifs_posix_lock_test(struct file *file, struct file_lock *flock)

fs/smb/client/file.c

1806

unsigned char saved_type = flock->c.flc_type;

fs/smb/client/file.c

1808

if ((flock->c.flc_flags & FL_POSIX) == 0)

fs/smb/client/file.c

1812

posix_test_lock(file, flock);

fs/smb/client/file.c

1814

if (lock_is_unlock(flock) && !cinode->can_cache_brlcks) {

fs/smb/client/file.c

1815

flock->c.flc_type = saved_type;

fs/smb/client/file.c

1831

cifs_posix_lock_set(struct file *file, struct file_lock *flock)

fs/smb/client/file.c

1836

if ((flock->c.flc_flags & FL_POSIX) == 0)

fs/smb/client/file.c

1845

rc = posix_lock_file(file, flock, NULL);

fs/smb/client/file.c

1949

struct file_lock *flock;

fs/smb/client/file.c

1986

for_each_file_lock(flock, &flctx->flc_posix) {

fs/smb/client/file.c

1987

unsigned char ftype = flock->c.flc_type;

fs/smb/client/file.c

1997

length = cifs_flock_len(flock);

fs/smb/client/file.c

2003

lck->pid = hash_lockowner(flock->c.flc_owner);

fs/smb/client/file.c

2007

lck->offset = flock->fl_start;

fs/smb/client/file.c

2067

cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,

fs/smb/client/file.c

2070

if (flock->c.flc_flags & FL_POSIX)

fs/smb/client/file.c

2072

if (flock->c.flc_flags & FL_FLOCK)

fs/smb/client/file.c

2074

if (flock->c.flc_flags & FL_SLEEP) {

fs/smb/client/file.c

2078

if (flock->c.flc_flags & FL_ACCESS)

fs/smb/client/file.c

2080

if (flock->c.flc_flags & FL_LEASE)

fs/smb/client/file.c

2082

if (flock->c.flc_flags &

fs/smb/client/file.c

2086

flock->c.flc_flags);

fs/smb/client/file.c

2089

if (lock_is_write(flock)) {

fs/smb/client/file.c

2093

} else if (lock_is_unlock(flock)) {

fs/smb/client/file.c

2098

} else if (lock_is_read(flock)) {

fs/smb/client/file.c

2102

} else if (flock->c.flc_type == F_EXLCK) {

fs/smb/client/file.c

2106

} else if (flock->c.flc_type == F_SHLCK) {

fs/smb/client/file.c

2115

cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,

fs/smb/client/file.c

2119

__u64 length = cifs_flock_len(flock);

fs/smb/client/file.c

2129

rc = cifs_posix_lock_test(file, flock);

fs/smb/client/file.c

2138

hash_lockowner(flock->c.flc_owner),

fs/smb/client/file.c

2139

flock->fl_start, length, flock,

fs/smb/client/file.c

2145

rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);

fs/smb/client/file.c

2150

rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,

fs/smb/client/file.c

2153

rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,

fs/smb/client/file.c

2155

flock->c.flc_type = F_UNLCK;

fs/smb/client/file.c

2163

flock->c.flc_type = F_WRLCK;

fs/smb/client/file.c

2169

rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,

fs/smb/client/file.c

2173

rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,

fs/smb/client/file.c

2175

flock->c.flc_type = F_RDLCK;

fs/smb/client/file.c

2180

flock->c.flc_type = F_WRLCK;

fs/smb/client/file.c

2229

cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,

fs/smb/client/file.c

2243

__u64 length = cifs_flock_len(flock);

fs/smb/client/file.c

2269

if (flock->fl_start > li->offset ||

fs/smb/client/file.c

2270

(flock->fl_start + length) <

fs/smb/client/file.c

2341

cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,

fs/smb/client/file.c

2346

__u64 length = cifs_flock_len(flock);

fs/smb/client/file.c

2356

rc = cifs_posix_lock_set(file, flock);

fs/smb/client/file.c

2369

hash_lockowner(flock->c.flc_owner),

fs/smb/client/file.c

2370

flock->fl_start, length,

fs/smb/client/file.c

2378

lock = cifs_lock_init(flock->fl_start, length, type,

fs/smb/client/file.c

2379

flock->c.flc_flags);

fs/smb/client/file.c

2406

rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,

fs/smb/client/file.c

2415

rc = server->ops->mand_unlock_range(cfile, flock, xid);

fs/smb/client/file.c

2418

if ((flock->c.flc_flags & FL_POSIX) || (flock->c.flc_flags & FL_FLOCK)) {

fs/smb/client/file.c

2427

if (!(flock->c.flc_flags & FL_CLOSE))

fs/smb/client/file.c

2430

rc = locks_lock_file_wait(file, flock);

fs/smb/client/file.c

2484

int cifs_lock(struct file *file, int cmd, struct file_lock *flock)

fs/smb/client/file.c

2499

flock->c.flc_flags, flock->c.flc_type,

fs/smb/client/file.c

2500

(long long)flock->fl_start,

fs/smb/client/file.c

2501

(long long)flock->fl_end);

fs/smb/client/file.c

2506

cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,

fs/smb/client/file.c

2519

rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);

fs/smb/client/file.c

2533

rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,

fs/smb/client/smb2file.c

286

smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,

fs/smb/client/smb2file.c

295

__u64 length = 1 + flock->fl_end - flock->fl_start;

fs/smb/client/smb2file.c

317

if (flock->fl_start > li->offset ||

fs/smb/client/smb2file.c

318

(flock->fl_start + length) <

fs/smb/client/smb2file.c

326

if (!(flock->c.flc_flags & (FL_FLOCK | FL_OFDLCK)))

fs/smb/client/smb2proto.h

112

int smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,

fs/smb/server/smb2pdu.c

7962

static int smb2_set_flock_flags(struct file_lock *flock, int flags)

fs/smb/server/smb2pdu.c

7971

flock->c.flc_type = F_RDLCK;

fs/smb/server/smb2pdu.c

7972

flock->c.flc_flags |= FL_SLEEP;

fs/smb/server/smb2pdu.c

7977

flock->c.flc_type = F_WRLCK;

fs/smb/server/smb2pdu.c

7978

flock->c.flc_flags |= FL_SLEEP;

fs/smb/server/smb2pdu.c

7984

flock->c.flc_type = F_RDLCK;

fs/smb/server/smb2pdu.c

7990

flock->c.flc_type = F_WRLCK;

fs/smb/server/smb2pdu.c

7994

flock->c.flc_type = F_UNLCK;

fs/smb/server/smb2pdu.c

8002

static struct ksmbd_lock *smb2_lock_init(struct file_lock *flock,

fs/smb/server/smb2pdu.c

8013

lock->fl = flock;

fs/smb/server/smb2pdu.c

8014

lock->start = flock->fl_start;

fs/smb/server/smb2pdu.c

8015

lock->end = flock->fl_end;

fs/smb/server/smb2pdu.c

8029

struct file_lock *flock = (struct file_lock *)argv[0];

fs/smb/server/smb2pdu.c

8031

ksmbd_vfs_posix_lock_unblock(flock);

fs/smb/server/smb2pdu.c

8032

locks_wake_up(flock);

fs/smb/server/smb2pdu.c

8053

struct file_lock *flock = NULL;

fs/smb/server/smb2pdu.c

8113

flock = smb_flock_init(filp);

fs/smb/server/smb2pdu.c

8114

if (!flock)

fs/smb/server/smb2pdu.c

8117

cmd = smb2_set_flock_flags(flock, flags);

fs/smb/server/smb2pdu.c

8124

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

8129

flock->fl_start = OFFSET_MAX;

fs/smb/server/smb2pdu.c

8131

flock->fl_start = lock_start;

fs/smb/server/smb2pdu.c

8134

if (lock_length > OFFSET_MAX - flock->fl_start)

fs/smb/server/smb2pdu.c

8135

lock_length = OFFSET_MAX - flock->fl_start;

fs/smb/server/smb2pdu.c

8137

flock->fl_end = flock->fl_start + lock_length;

fs/smb/server/smb2pdu.c

8139

if (flock->fl_end < flock->fl_start) {

fs/smb/server/smb2pdu.c

8142

flock->fl_end, flock->fl_start);

fs/smb/server/smb2pdu.c

8144

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

8150

if (cmp_lock->fl->fl_start <= flock->fl_start &&

fs/smb/server/smb2pdu.c

8151

cmp_lock->fl->fl_end >= flock->fl_end) {

fs/smb/server/smb2pdu.c

8153

flock->c.flc_type != F_UNLCK) {

fs/smb/server/smb2pdu.c

8156

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

8162

smb_lock = smb2_lock_init(flock, cmd, flags, &lock_list);

fs/smb/server/smb2pdu.c

8165

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

8274

flock = smb_lock->fl;

fs/smb/server/smb2pdu.c

8282

rc = vfs_lock_file(filp, smb_lock->cmd, flock, NULL);

fs/smb/server/smb2pdu.c

8285

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

8307

argv[0] = flock;

fs/smb/server/smb2pdu.c

8323

ksmbd_vfs_posix_lock_wait(flock);

fs/smb/server/smb2pdu.c

8335

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

8361

locks_free_lock(flock);

fs/smb/server/vfs.c

1822

void ksmbd_vfs_posix_lock_wait(struct file_lock *flock)

fs/smb/server/vfs.c

1824

wait_event(flock->c.flc_wait, !flock->c.flc_blocker);

fs/smb/server/vfs.c

1827

void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock)

fs/smb/server/vfs.c

1829

locks_delete_block(flock);

fs/smb/server/vfs.c

296

struct file_lock *flock;

fs/smb/server/vfs.c

307

for_each_file_lock(flock, &ctx->flc_posix) {

fs/smb/server/vfs.c

309

if (flock->fl_end >= start && end >= flock->fl_start) {

fs/smb/server/vfs.c

310

if (lock_is_read(flock)) {

fs/smb/server/vfs.c

316

} else if (lock_is_write(flock)) {

fs/smb/server/vfs.c

318

if (flock->c.flc_file != filp) {

fs/smb/server/vfs.h

145

void ksmbd_vfs_posix_lock_wait(struct file_lock *flock);

fs/smb/server/vfs.h

146

void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock);

include/linux/filelock.h

164

int fcntl_getlk(struct file *, unsigned int, struct flock *);

include/linux/filelock.h

166

struct flock *);

include/linux/filelock.h

264

struct flock __user *user)

include/linux/filelock.h

270

unsigned int cmd, struct flock __user *user)

include/linux/fs.h

1944

int (*flock) (struct file *, int, struct file_lock *);

include/net/9p/client.h

324

int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status);

kernel/sys_ni.c

66

COND_SYSCALL(flock);

net/9p/client.c

2111

int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status)

net/9p/client.c

2120

fid->fid, flock->type, flock->flags, flock->start,

net/9p/client.c

2121

flock->length, flock->proc_id, flock->client_id);

net/9p/client.c

2123

req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type,

net/9p/client.c

2124

flock->flags, flock->start, flock->length,

net/9p/client.c

2125

flock->proc_id, flock->client_id);

tools/hv/hv_kvp_daemon.c

136

struct flock fl = {F_WRLCK, SEEK_SET, 0, 0, 0};

tools/hv/hv_kvp_daemon.c

148

struct flock fl = {F_UNLCK, SEEK_SET, 0, 0, 0};

tools/perf/builtin-daemon.c

1128

return flock(fd, LOCK_EX | LOCK_NB);

tools/perf/util/bpf_counter.c

418

err = flock(map_fd, LOCK_EX);

tools/perf/util/bpf_counter.c

651

flock(attr_map_fd, LOCK_UN);

tools/power/x86/intel-speed-select/isst-daemon.c

219

if (flock(pid_file_handle, LOCK_EX|LOCK_NB) < 0) {

tools/testing/selftests/filelock/ofdlocks.c

11

static int lock_set(int fd, struct flock *fl)

tools/testing/selftests/filelock/ofdlocks.c

23

static int lock_get(int fd, struct flock *fl)

tools/testing/selftests/filelock/ofdlocks.c

38

struct flock fl, fl2;

tools/testing/selftests/powerpc/nx-gzip/include/nx_dbg.h

34

flock(nx_gzip_log->_fileno, LOCK_EX); \

tools/testing/selftests/powerpc/nx-gzip/include/nx_dbg.h

42

flock(nx_gzip_log->_fileno, LOCK_UN); \