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

43

.flock = afs_flock,

fs/ceph/dir.c

2229

.flock = ceph_flock,

fs/ceph/file.c

3187

.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

2464

int flock, struct fuse_lk_in *inarg)

fs/fuse/file.c

2477

if (flock)

fs/fuse/file.c

2506

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

fs/fuse/file.c

2522

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

fs/fuse/file.c

2567

ff->flock = true;

fs/fuse/file.c

3173

.flock = fuse_file_flock,

fs/fuse/file.c

358

if (ra && ff->flock) {

fs/fuse/fuse_i.h

308

bool flock:1;

fs/gfs2/file.c

1593

.flock = gfs2_flock,

fs/gfs2/file.c

1608

.flock = gfs2_flock,

fs/locks.c

2198

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

fs/locks.c

2237

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

fs/locks.c

2238

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

fs/locks.c

2319

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

fs/locks.c

2321

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

fs/locks.c

2332

flock->l_start = fl->fl_start;

fs/locks.c

2333

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

fs/locks.c

2335

flock->l_whence = 0;

fs/locks.c

2336

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

fs/locks.c

2341

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

fs/locks.c

2343

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

fs/locks.c

2344

flock->l_start = fl->fl_start;

fs/locks.c

2345

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

fs/locks.c

2347

flock->l_whence = 0;

fs/locks.c

2348

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

fs/locks.c

2355

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

fs/locks.c

2364

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

fs/locks.c

2365

&& flock->l_type != F_WRLCK)

fs/locks.c

2368

error = flock_to_posix_lock(filp, fl, flock);

fs/locks.c

2374

if (flock->l_pid != 0)

fs/locks.c

2385

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

fs/locks.c

2387

error = posix_lock_to_flock(flock, fl);

fs/locks.c

2484

struct flock *flock)

fs/locks.c

2494

error = flock_to_posix_lock(filp, file_lock, flock);

fs/locks.c

2509

if (flock->l_pid != 0)

fs/locks.c

2518

if (flock->l_pid != 0)

fs/locks.c

2563

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

fs/locks.c

2573

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

fs/locks.c

2574

&& flock->l_type != F_WRLCK)

fs/locks.c

2577

error = flock64_to_posix_lock(filp, fl, flock);

fs/locks.c

2583

if (flock->l_pid != 0)

fs/locks.c

2594

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

fs/locks.c

2596

posix_lock_to_flock64(flock, fl);

fs/locks.c

2607

struct flock64 *flock)

fs/locks.c

2616

error = flock64_to_posix_lock(filp, file_lock, flock);

fs/locks.c

2631

if (flock->l_pid != 0)

fs/locks.c

2640

if (flock->l_pid != 0)

fs/locks.c

2734

if (filp->f_op->flock)

fs/locks.c

2735

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

fs/locks.c

561

struct flock *l)

fs/nfs/file.c

962

.flock = nfs_flock,

fs/nfs/nfs4file.c

445

.flock = nfs_flock,

fs/ocfs2/file.c

2821

.flock = ocfs2_flock,

fs/ocfs2/file.c

2843

.flock = ocfs2_flock,

fs/ocfs2/file.c

2872

.flock = ocfs2_flock,

fs/ocfs2/file.c

2891

.flock = ocfs2_flock,

fs/smb/client/cifsfs.c

1605

.flock = cifs_flock,

fs/smb/client/cifsfs.c

1625

.flock = cifs_flock,

fs/smb/client/cifsfs.c

1645

.flock = cifs_flock,

fs/smb/client/cifsfs.h

108

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

1668

__u8 type, struct file_lock *flock)

fs/smb/client/file.c

1679

flock->c.flc_flags, &conf_lock,

fs/smb/client/file.c

1682

flock->fl_start = conf_lock->offset;

fs/smb/client/file.c

1683

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

fs/smb/client/file.c

1684

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

fs/smb/client/file.c

1686

flock->c.flc_type = F_RDLCK;

fs/smb/client/file.c

1688

flock->c.flc_type = F_WRLCK;

fs/smb/client/file.c

1692

flock->c.flc_type = F_UNLCK;

fs/smb/client/file.c

1764

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

fs/smb/client/file.c

1768

unsigned char saved_type = flock->c.flc_type;

fs/smb/client/file.c

1770

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

fs/smb/client/file.c

1774

posix_test_lock(file, flock);

fs/smb/client/file.c

1776

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

fs/smb/client/file.c

1777

flock->c.flc_type = saved_type;

fs/smb/client/file.c

1793

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

fs/smb/client/file.c

1798

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

fs/smb/client/file.c

1807

rc = posix_lock_file(file, flock, NULL);

fs/smb/client/file.c

1911

struct file_lock *flock;

fs/smb/client/file.c

1948

for_each_file_lock(flock, &flctx->flc_posix) {

fs/smb/client/file.c

1949

unsigned char ftype = flock->c.flc_type;

fs/smb/client/file.c

1959

length = cifs_flock_len(flock);

fs/smb/client/file.c

1965

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

fs/smb/client/file.c

1969

lck->offset = flock->fl_start;

fs/smb/client/file.c

2029

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

fs/smb/client/file.c

2032

if (flock->c.flc_flags & FL_POSIX)

fs/smb/client/file.c

2034

if (flock->c.flc_flags & FL_FLOCK)

fs/smb/client/file.c

2036

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

fs/smb/client/file.c

2040

if (flock->c.flc_flags & FL_ACCESS)

fs/smb/client/file.c

2042

if (flock->c.flc_flags & FL_LEASE)

fs/smb/client/file.c

2044

if (flock->c.flc_flags &

fs/smb/client/file.c

2048

flock->c.flc_flags);

fs/smb/client/file.c

2051

if (lock_is_write(flock)) {

fs/smb/client/file.c

2055

} else if (lock_is_unlock(flock)) {

fs/smb/client/file.c

2060

} else if (lock_is_read(flock)) {

fs/smb/client/file.c

2064

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

fs/smb/client/file.c

2068

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

fs/smb/client/file.c

2077

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

fs/smb/client/file.c

2081

__u64 length = cifs_flock_len(flock);

fs/smb/client/file.c

2091

rc = cifs_posix_lock_test(file, flock);

fs/smb/client/file.c

2100

hash_lockowner(flock->c.flc_owner),

fs/smb/client/file.c

2101

flock->fl_start, length, flock,

fs/smb/client/file.c

2107

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

fs/smb/client/file.c

2112

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

fs/smb/client/file.c

2115

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

fs/smb/client/file.c

2117

flock->c.flc_type = F_UNLCK;

fs/smb/client/file.c

2125

flock->c.flc_type = F_WRLCK;

fs/smb/client/file.c

2131

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

fs/smb/client/file.c

2135

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

fs/smb/client/file.c

2137

flock->c.flc_type = F_RDLCK;

fs/smb/client/file.c

2142

flock->c.flc_type = F_WRLCK;

fs/smb/client/file.c

2191

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

fs/smb/client/file.c

2205

__u64 length = cifs_flock_len(flock);

fs/smb/client/file.c

2231

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

fs/smb/client/file.c

2232

(flock->fl_start + length) <

fs/smb/client/file.c

2303

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

fs/smb/client/file.c

2308

__u64 length = cifs_flock_len(flock);

fs/smb/client/file.c

2318

rc = cifs_posix_lock_set(file, flock);

fs/smb/client/file.c

2331

hash_lockowner(flock->c.flc_owner),

fs/smb/client/file.c

2332

flock->fl_start, length,

fs/smb/client/file.c

2340

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

fs/smb/client/file.c

2341

flock->c.flc_flags);

fs/smb/client/file.c

2368

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

fs/smb/client/file.c

2377

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

fs/smb/client/file.c

2380

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

fs/smb/client/file.c

2389

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

fs/smb/client/file.c

2392

rc = locks_lock_file_wait(file, flock);

fs/smb/client/file.c

2446

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

fs/smb/client/file.c

2461

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

fs/smb/client/file.c

2462

(long long)flock->fl_start,

fs/smb/client/file.c

2463

(long long)flock->fl_end);

fs/smb/client/file.c

2468

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

fs/smb/client/file.c

2481

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

fs/smb/client/file.c

2495

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

fs/smb/client/smb2file.c

265

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

fs/smb/client/smb2file.c

274

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

fs/smb/client/smb2file.c

296

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

fs/smb/client/smb2file.c

297

(flock->fl_start + length) <

fs/smb/client/smb2file.c

305

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

7369

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

fs/smb/server/smb2pdu.c

7378

flock->c.flc_type = F_RDLCK;

fs/smb/server/smb2pdu.c

7379

flock->c.flc_flags |= FL_SLEEP;

fs/smb/server/smb2pdu.c

7384

flock->c.flc_type = F_WRLCK;

fs/smb/server/smb2pdu.c

7385

flock->c.flc_flags |= FL_SLEEP;

fs/smb/server/smb2pdu.c

7391

flock->c.flc_type = F_RDLCK;

fs/smb/server/smb2pdu.c

7397

flock->c.flc_type = F_WRLCK;

fs/smb/server/smb2pdu.c

7401

flock->c.flc_type = F_UNLCK;

fs/smb/server/smb2pdu.c

7409

static struct ksmbd_lock *smb2_lock_init(struct file_lock *flock,

fs/smb/server/smb2pdu.c

7420

lock->fl = flock;

fs/smb/server/smb2pdu.c

7421

lock->start = flock->fl_start;

fs/smb/server/smb2pdu.c

7422

lock->end = flock->fl_end;

fs/smb/server/smb2pdu.c

7436

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

fs/smb/server/smb2pdu.c

7438

ksmbd_vfs_posix_lock_unblock(flock);

fs/smb/server/smb2pdu.c

7439

locks_wake_up(flock);

fs/smb/server/smb2pdu.c

7460

struct file_lock *flock = NULL;

fs/smb/server/smb2pdu.c

7497

flock = smb_flock_init(filp);

fs/smb/server/smb2pdu.c

7498

if (!flock)

fs/smb/server/smb2pdu.c

7501

cmd = smb2_set_flock_flags(flock, flags);

fs/smb/server/smb2pdu.c

7508

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

7513

flock->fl_start = OFFSET_MAX;

fs/smb/server/smb2pdu.c

7515

flock->fl_start = lock_start;

fs/smb/server/smb2pdu.c

7518

if (lock_length > OFFSET_MAX - flock->fl_start)

fs/smb/server/smb2pdu.c

7519

lock_length = OFFSET_MAX - flock->fl_start;

fs/smb/server/smb2pdu.c

7521

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

fs/smb/server/smb2pdu.c

7523

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

fs/smb/server/smb2pdu.c

7526

flock->fl_end, flock->fl_start);

fs/smb/server/smb2pdu.c

7528

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

7534

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

fs/smb/server/smb2pdu.c

7535

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

fs/smb/server/smb2pdu.c

7537

flock->c.flc_type != F_UNLCK) {

fs/smb/server/smb2pdu.c

7540

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

7546

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

fs/smb/server/smb2pdu.c

7549

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

7656

flock = smb_lock->fl;

fs/smb/server/smb2pdu.c

7664

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

fs/smb/server/smb2pdu.c

7667

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

7689

argv[0] = flock;

fs/smb/server/smb2pdu.c

7705

ksmbd_vfs_posix_lock_wait(flock);

fs/smb/server/smb2pdu.c

7713

locks_free_lock(flock);

fs/smb/server/smb2pdu.c

7744

locks_free_lock(flock);

fs/smb/server/vfs.c

1791

void ksmbd_vfs_posix_lock_wait(struct file_lock *flock)

fs/smb/server/vfs.c

1793

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

fs/smb/server/vfs.c

1796

void ksmbd_vfs_posix_lock_unblock(struct file_lock *flock)

fs/smb/server/vfs.c

1798

locks_delete_block(flock);

fs/smb/server/vfs.c

299

struct file_lock *flock;

fs/smb/server/vfs.c

310

for_each_file_lock(flock, &ctx->flc_posix) {

fs/smb/server/vfs.c

312

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

fs/smb/server/vfs.c

313

if (lock_is_read(flock)) {

fs/smb/server/vfs.c

319

} else if (lock_is_write(flock)) {

fs/smb/server/vfs.c

321

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

151

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

include/linux/filelock.h

153

struct flock *);

include/linux/filelock.h

257

struct flock __user *user)

include/linux/filelock.h

263

unsigned int cmd, struct flock __user *user)

include/linux/fs.h

1949

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

include/net/9p/client.h

322

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

2108

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

net/9p/client.c

2117

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

net/9p/client.c

2118

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

net/9p/client.c

2120

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

net/9p/client.c

2121

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

net/9p/client.c

2122

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

416

err = flock(map_fd, LOCK_EX);

tools/perf/util/bpf_counter.c

649

flock(attr_map_fd, LOCK_UN);

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

212

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); \