Searched refs:flock (Results 1 - 57 of 57) sorted by relevance

/linux-4.1.27/fs/afs/
H A DMakefile14 flock.o \
H A Dfile.c40 .flock = afs_flock,
H A Dflock.c557 /* we're simulating flock() locks using posix locks on the server */ afs_flock()
H A Dinternal.h504 * flock.c
/linux-4.1.27/arch/mips/include/uapi/asm/
H A Dfcntl.h53 * The flavours of struct flock. "struct flock" is the ABI compliant
54 * variant. Finally struct flock64 is the LFS variant of struct flock. As
56 * contain all the same fields as struct flock.
63 struct flock { struct
/linux-4.1.27/include/uapi/asm-generic/
H A Dfcntl.h143 * process. This means that they are inherited across fork() like BSD (flock)
170 /* for old implementation of bsd flock () */
176 /* operations for bsd flock(), also used by the kernel implementation */
183 #define LOCK_MAND 32 /* This is a mandatory flock ... */
195 struct flock { struct
/linux-4.1.27/fs/9p/
H A Dvfs_file.c152 struct p9_flock flock; v9fs_file_do_lock() local
169 memset(&flock, 0, sizeof(flock)); v9fs_file_do_lock()
173 flock.type = P9_LOCK_TYPE_RDLCK; v9fs_file_do_lock()
176 flock.type = P9_LOCK_TYPE_WRLCK; v9fs_file_do_lock()
179 flock.type = P9_LOCK_TYPE_UNLCK; v9fs_file_do_lock()
182 flock.start = fl->fl_start; v9fs_file_do_lock()
184 flock.length = 0; v9fs_file_do_lock()
186 flock.length = fl->fl_end - fl->fl_start + 1; v9fs_file_do_lock()
187 flock.proc_id = fl->fl_pid; v9fs_file_do_lock()
188 flock.client_id = fid->clnt->name; v9fs_file_do_lock()
190 flock.flags = P9_LOCK_FLAGS_BLOCK; v9fs_file_do_lock()
197 res = p9_client_lock_dotl(fid, &flock, &status); v9fs_file_do_lock()
359 /* Convert flock to posix lock */ v9fs_file_flock_dotl()
656 .flock = v9fs_file_flock_dotl,
679 .flock = v9fs_file_flock_dotl,
702 .flock = v9fs_file_flock_dotl,
/linux-4.1.27/fs/
H A Dlocks.c36 * FL_FLOCK locks are created with calls to flock(), through the flock()
37 * system call, which is new. Old C libraries implement flock() via fcntl()
40 * FL_FLOCK locks follow the 4.4 BSD flock() semantics. They are associated
76 * flock() and fcntl().
453 /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
457 struct flock *l) flock_to_posix_lock()
1878 * sys_flock: - flock() system call.
1891 * %LOCK_MAND -- a `mandatory' flock. This exists to emulate Windows Share Modes.
1896 SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd) SYSCALL_DEFINE2()
1928 if (f.file->f_op->flock) SYSCALL_DEFINE2()
1929 error = f.file->f_op->flock(f.file, SYSCALL_DEFINE2()
1961 static int posix_lock_to_flock(struct flock *flock, struct file_lock *fl) posix_lock_to_flock() argument
1963 flock->l_pid = IS_OFDLCK(fl) ? -1 : fl->fl_pid; posix_lock_to_flock()
1967 * legacy 32bit flock. posix_lock_to_flock()
1974 flock->l_start = fl->fl_start; posix_lock_to_flock()
1975 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : posix_lock_to_flock()
1977 flock->l_whence = 0; posix_lock_to_flock()
1978 flock->l_type = fl->fl_type; posix_lock_to_flock()
1983 static void posix_lock_to_flock64(struct flock64 *flock, struct file_lock *fl) posix_lock_to_flock64() argument
1985 flock->l_pid = IS_OFDLCK(fl) ? -1 : fl->fl_pid; posix_lock_to_flock64()
1986 flock->l_start = fl->fl_start; posix_lock_to_flock64()
1987 flock->l_len = fl->fl_end == OFFSET_MAX ? 0 : posix_lock_to_flock64()
1989 flock->l_whence = 0; posix_lock_to_flock64()
1990 flock->l_type = fl->fl_type; posix_lock_to_flock64()
1997 int fcntl_getlk(struct file *filp, unsigned int cmd, struct flock __user *l) fcntl_getlk()
2000 struct flock flock; fcntl_getlk() local
2004 if (copy_from_user(&flock, l, sizeof(flock))) fcntl_getlk()
2007 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) fcntl_getlk()
2010 error = flock_to_posix_lock(filp, &file_lock, &flock); fcntl_getlk()
2016 if (flock.l_pid != 0) fcntl_getlk()
2028 flock.l_type = file_lock.fl_type; fcntl_getlk()
2030 error = posix_lock_to_flock(&flock, &file_lock); fcntl_getlk()
2035 if (!copy_to_user(l, &flock, sizeof(flock))) fcntl_getlk()
2129 struct flock __user *l) fcntl_setlk()
2132 struct flock flock; fcntl_setlk() local
2144 if (copy_from_user(&flock, l, sizeof(flock))) fcntl_setlk()
2157 error = flock_to_posix_lock(filp, file_lock, &flock); fcntl_setlk()
2172 if (flock.l_pid != 0) fcntl_setlk()
2181 if (flock.l_pid != 0) fcntl_setlk()
2226 struct flock64 flock; fcntl_getlk64() local
2230 if (copy_from_user(&flock, l, sizeof(flock))) fcntl_getlk64()
2233 if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK)) fcntl_getlk64()
2236 error = flock64_to_posix_lock(filp, &file_lock, &flock); fcntl_getlk64()
2242 if (flock.l_pid != 0) fcntl_getlk64()
2254 flock.l_type = file_lock.fl_type; fcntl_getlk64()
2256 posix_lock_to_flock64(&flock, &file_lock); fcntl_getlk64()
2259 if (!copy_to_user(l, &flock, sizeof(flock))) fcntl_getlk64()
2274 struct flock64 flock; fcntl_setlk64() local
2286 if (copy_from_user(&flock, l, sizeof(flock))) fcntl_setlk64()
2299 error = flock64_to_posix_lock(filp, file_lock, &flock); fcntl_setlk64()
2314 if (flock.l_pid != 0) fcntl_setlk64()
2323 if (flock.l_pid != 0) fcntl_setlk64()
2416 if (filp->f_op->flock) locks_remove_flock()
2417 filp->f_op->flock(filp, F_SETLKW, &fl); locks_remove_flock()
2456 /* remove flock locks */ locks_remove_file()
H A Dcompat.c350 static int get_compat_flock(struct flock *kfl, struct compat_flock __user *ufl) get_compat_flock()
362 static int put_compat_flock(struct flock *kfl, struct compat_flock __user *ufl) put_compat_flock()
375 static int get_compat_flock64(struct flock *kfl, struct compat_flock64 __user *ufl) get_compat_flock64()
389 static int put_compat_flock64(struct flock *kfl, struct compat_flock64 __user *ufl) put_compat_flock64()
421 struct flock f; COMPAT_SYSCALL_DEFINE3()
H A Dfcntl.c273 err = fcntl_getlk(filp, cmd, (struct flock __user *) arg); do_fcntl()
283 err = fcntl_setlk(fd, filp, cmd, (struct flock __user *) arg); do_fcntl()
/linux-4.1.27/drivers/staging/lustre/lustre/ldlm/
H A Dldlm_flock.c54 * These flock locks never timeout.
179 struct ldlm_flock *flock; ldlm_flock_deadlock() local
188 flock = &lock->l_policy_data.l_flock; ldlm_flock_deadlock()
189 LASSERT(flock->owner == bl_owner); ldlm_flock_deadlock()
190 bl_owner = flock->blocking_owner; ldlm_flock_deadlock()
191 bl_exp_new = class_export_get(flock->blocking_export); ldlm_flock_deadlock()
215 "deadlock found, but client doesn't support flock canceliation\n"); ldlm_flock_cancel_on_deadlock()
228 * Process a granting attempt for flock lock.
534 /* The only one possible case for client-side calls flock ldlm_process_flock_lock()
760 * Export handle<->flock hash operations.
793 struct ldlm_flock *flock; ldlm_export_flock_get() local
798 flock = &lock->l_policy_data.l_flock; ldlm_export_flock_get()
799 LASSERT(flock->blocking_export != NULL); ldlm_export_flock_get()
800 class_export_get(flock->blocking_export); ldlm_export_flock_get()
801 flock->blocking_refs++; ldlm_export_flock_get()
808 struct ldlm_flock *flock; ldlm_export_flock_put() local
813 flock = &lock->l_policy_data.l_flock; ldlm_export_flock_put()
814 LASSERT(flock->blocking_export != NULL); ldlm_export_flock_put()
815 class_export_put(flock->blocking_export); ldlm_export_flock_put()
816 if (--flock->blocking_refs == 0) { ldlm_export_flock_put()
817 flock->blocking_owner = 0; ldlm_export_flock_put()
818 flock->blocking_export = NULL; ldlm_export_flock_put()
H A Dldlm_pool.c915 * also there is no LRU for flock locks, so no point in tracking ldlm_pool_add()
H A Dldlm_lock.c761 * Does NOT add lock to LRU if no r/w references left to accommodate flock locks
H A Dldlm_request.c490 * a client for flock locks. As such this is the place where we must failed_lock_cleanup()
/linux-4.1.27/fs/ceph/
H A Dlocks.c33 * Implement fcntl and flock locking functions.
263 dout("counted %d flock locks and %d fcntl locks", ceph_count_locks()
268 * Encode the flock and fcntl locks for the given inode into the ceph_filelock
283 dout("encoding %d flock and %d fcntl locks", num_flock_locks, ceph_encode_locks_to_buffer()
318 * Copy the encoded flock and fcntl locks into the pagelist.
319 * Format is: #fcntl locks, sequential fcntl locks, #flock locks,
320 * sequential flock locks.
H A Dmds_client.c50 bool flock; member in struct:ceph_reconnect_state
2769 if (recon_state->flock) { encode_caps_cb()
2790 if (recon_state->flock) { encode_caps_cb()
2916 recon_state.flock = session->s_con.peer_features & CEPH_FEATURE_FLOCK; send_mds_reconnect()
2945 if (recon_state.flock) send_mds_reconnect()
H A Dfile.c1337 .flock = ceph_flock,
H A Dcaps.c1002 /* flock buffer size + inline version + inline data size */ send_cap_msg()
1038 /* flock buffer size */ send_cap_msg()
/linux-4.1.27/fs/cifs/
H A Dfile.c890 * style). If such a lock exists, update the flock structure with its
891 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
897 __u8 type, struct file_lock *flock) cifs_lock_test()
910 flock->fl_start = conf_lock->offset; cifs_lock_test()
911 flock->fl_end = conf_lock->offset + conf_lock->length - 1; cifs_lock_test()
912 flock->fl_pid = conf_lock->pid; cifs_lock_test()
914 flock->fl_type = F_RDLCK; cifs_lock_test()
916 flock->fl_type = F_WRLCK; cifs_lock_test()
920 flock->fl_type = F_UNLCK; cifs_lock_test()
984 * style). If such a lock exists, update the flock structure with its
985 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
990 cifs_posix_lock_test(struct file *file, struct file_lock *flock) cifs_posix_lock_test() argument
994 unsigned char saved_type = flock->fl_type; cifs_posix_lock_test()
996 if ((flock->fl_flags & FL_POSIX) == 0) cifs_posix_lock_test()
1000 posix_test_lock(file, flock); cifs_posix_lock_test()
1002 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) { cifs_posix_lock_test()
1003 flock->fl_type = saved_type; cifs_posix_lock_test()
1018 cifs_posix_lock_set(struct file *file, struct file_lock *flock) cifs_posix_lock_set() argument
1023 if ((flock->fl_flags & FL_POSIX) == 0) cifs_posix_lock_set()
1033 rc = posix_lock_file(file, flock, NULL); cifs_posix_lock_set()
1036 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next); cifs_posix_lock_set()
1039 posix_unblock_lock(flock); cifs_posix_lock_set()
1129 struct file_lock *flock; cifs_push_posix_locks() local
1166 list_for_each_entry(flock, &flctx->flc_posix, fl_list) { cifs_push_posix_locks()
1175 length = 1 + flock->fl_end - flock->fl_start; cifs_push_posix_locks()
1176 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK) cifs_push_posix_locks()
1181 lck->pid = flock->fl_pid; cifs_push_posix_locks()
1185 lck->offset = flock->fl_start; cifs_push_posix_locks()
1240 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock, cifs_read_flock() argument
1243 if (flock->fl_flags & FL_POSIX) cifs_read_flock()
1245 if (flock->fl_flags & FL_FLOCK) cifs_read_flock()
1247 if (flock->fl_flags & FL_SLEEP) { cifs_read_flock()
1251 if (flock->fl_flags & FL_ACCESS) cifs_read_flock()
1253 if (flock->fl_flags & FL_LEASE) cifs_read_flock()
1255 if (flock->fl_flags & cifs_read_flock()
1258 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags); cifs_read_flock()
1261 if (flock->fl_type == F_WRLCK) { cifs_read_flock()
1265 } else if (flock->fl_type == F_UNLCK) { cifs_read_flock()
1270 } else if (flock->fl_type == F_RDLCK) { cifs_read_flock()
1274 } else if (flock->fl_type == F_EXLCK) { cifs_read_flock()
1278 } else if (flock->fl_type == F_SHLCK) { cifs_read_flock()
1287 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, cifs_getlk() argument
1291 __u64 length = 1 + flock->fl_end - flock->fl_start; cifs_getlk()
1300 rc = cifs_posix_lock_test(file, flock); cifs_getlk()
1309 flock->fl_start, length, flock, cifs_getlk()
1314 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock); cifs_getlk()
1319 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type, cifs_getlk()
1322 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, cifs_getlk()
1324 flock->fl_type = F_UNLCK; cifs_getlk()
1332 flock->fl_type = F_WRLCK; cifs_getlk()
1338 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, cifs_getlk()
1342 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, cifs_getlk()
1344 flock->fl_type = F_RDLCK; cifs_getlk()
1349 flock->fl_type = F_WRLCK; cifs_getlk()
1374 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, cifs_unlock_range() argument
1386 __u64 length = 1 + flock->fl_end - flock->fl_start; cifs_unlock_range()
1410 if (flock->fl_start > li->offset || cifs_unlock_range()
1411 (flock->fl_start + length) < cifs_unlock_range()
1481 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, cifs_setlk() argument
1486 __u64 length = 1 + flock->fl_end - flock->fl_start; cifs_setlk()
1495 rc = cifs_posix_lock_set(file, flock); cifs_setlk()
1508 current->tgid, flock->fl_start, length, cifs_setlk()
1516 lock = cifs_lock_init(flock->fl_start, length, type); cifs_setlk()
1543 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, cifs_setlk()
1552 rc = server->ops->mand_unlock_range(cfile, flock, xid); cifs_setlk()
1555 if (flock->fl_flags & FL_POSIX && !rc) cifs_setlk()
1556 rc = posix_lock_file_wait(file, flock); cifs_setlk()
1560 int cifs_lock(struct file *file, int cmd, struct file_lock *flock) cifs_lock() argument
1577 cmd, flock->fl_flags, flock->fl_type, cifs_lock()
1578 flock->fl_start, flock->fl_end); cifs_lock()
1583 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag, cifs_lock()
1599 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid); cifs_lock()
1613 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock, cifs_lock()
896 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length, __u8 type, struct file_lock *flock) cifs_lock_test() argument
H A Dsmb2file.c91 smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, smb2_unlock_range() argument
100 __u64 length = 1 + flock->fl_end - flock->fl_start; smb2_unlock_range()
122 if (flock->fl_start > li->offset || smb2_unlock_range()
123 (flock->fl_start + length) < smb2_unlock_range()
H A Dsmb2proto.h96 struct file_lock *flock, const unsigned int xid);
H A Dcifsproto.h140 struct file_lock *flock, const unsigned int xid);
/linux-4.1.27/arch/alpha/include/uapi/asm/
H A Dfcntl.h51 /* for old implementation of bsd flock () */
/linux-4.1.27/fs/nfs/
H A Dnfs4file.c181 .flock = nfs_flock,
H A Dfile.c906 dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n", nfs_flock()
924 /* We're simulating flock() locks using posix locks on the server */ nfs_flock()
941 .flock = nfs_flock,
H A Dsuper.c262 { Opt_local_lock_flock, "flock" },
710 seq_printf(m, ",local_lock=flock"); nfs_show_mount_options()
H A Dnfs4proc.c6001 * since it won't do this for flock() locks. nfs4_proc_lock()
/linux-4.1.27/net/9p/
H A Dclient.c2174 int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status) p9_client_lock_dotl() argument
2184 fid->fid, flock->type, flock->flags, flock->start, p9_client_lock_dotl()
2185 flock->length, flock->proc_id, flock->client_id); p9_client_lock_dotl()
2187 req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type, p9_client_lock_dotl()
2188 flock->flags, flock->start, flock->length, p9_client_lock_dotl()
2189 flock->proc_id, flock->client_id); p9_client_lock_dotl()
/linux-4.1.27/arch/um/os-Linux/
H A Dfile.c554 struct flock lock = ((struct flock) { .l_type = type, os_lock_file()
/linux-4.1.27/include/linux/ceph/
H A Dceph_fs.h388 __u8 rule; /* currently fcntl or flock */
707 __le32 flock_len; /* size of flock state blob, if any */
709 /* followed by flock blob */
/linux-4.1.27/drivers/staging/lustre/lustre/llite/
H A Dfile.c2691 ldlm_policy_data_t flock = {{0}}; ll_file_flock() local
2706 flock.l_flock.owner = (unsigned long)file_lock->fl_owner; ll_file_flock()
2707 flock.l_flock.pid = file_lock->fl_pid; ll_file_flock()
2708 flock.l_flock.start = file_lock->fl_start; ll_file_flock()
2709 flock.l_flock.end = file_lock->fl_end; ll_file_flock()
2719 flock.l_flock.owner = (unsigned long)file_lock->fl_pid; ll_file_flock()
2733 * message we'll treat a LCK_NL flock request as an unlock. */ ll_file_flock()
2778 inode->i_ino, flock.l_flock.pid, flags, einfo.ei_mode, ll_file_flock()
2779 flock.l_flock.start, flock.l_flock.end); ll_file_flock()
2782 op_data, &lockh, &flock, 0, NULL /* req */, flags); ll_file_flock()
2795 op_data, &lockh, &flock, 0, NULL /* req */, flags); ll_file_flock()
3136 /* -o localflock - only provides locally consistent flock locks */
3161 .flock = ll_file_flock,
3165 /* These are for -o noflock - to return ENOSYS on flock calls */
3177 .flock = ll_file_noflock,
H A Dllite_lib.c231 /* force vfs to use lustre handler for flock() calls - bug 10743 */ client_common_fill_super()
742 tmp = ll_set_opt("flock", s1, LL_SBI_FLOCK); ll_options()
2253 seq_puts(seq, ",flock"); ll_show_options()
H A Dllite_internal.h424 "flock", \
431 "flock", \
H A Dlproc_llite.c905 { LPROC_LL_FLOCK, LPROCFS_TYPE_REGS, "flock" },
/linux-4.1.27/arch/powerpc/include/asm/
H A Dsystbl.h150 SYSCALL_SPU(flock)
/linux-4.1.27/fs/fuse/
H A Dfile.c258 if (ff->flock) { fuse_release_common()
2098 int flock, struct fuse_lk_in *inarg) fuse_lk_fill()
2111 if (flock) fuse_lk_fill()
2140 static int fuse_setlk(struct file *file, struct file_lock *fl, int flock) fuse_setlk() argument
2159 fuse_lk_fill(&args, file, fl, opcode, pid, flock, &inarg); fuse_setlk()
2203 /* emulate flock with POSIX locks */ fuse_file_flock()
2204 ff->flock = true; fuse_file_flock()
2966 .flock = fuse_file_flock,
2984 .flock = fuse_file_flock,
2096 fuse_lk_fill(struct fuse_args *args, struct file *file, const struct file_lock *fl, int opcode, pid_t pid, int flock, struct fuse_lk_in *inarg) fuse_lk_fill() argument
H A Dfuse_i.h159 /** Has flock been performed on this file? */
160 bool flock:1; member in struct:fuse_file
/linux-4.1.27/drivers/staging/lustre/lustre/mdc/
H A Dmdc_locks.c824 /* The only way right now is FLOCK, in this case we hide flock mdc_enqueue()
872 * rpcs in flight counter. We do not do flock request limiting, though*/ mdc_enqueue()
887 /* For flock requests we immediately return without further mdc_enqueue()
889 this function metadata processing makes no sense for flock mdc_enqueue()
/linux-4.1.27/include/net/9p/
H A Dclient.h257 int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status);
/linux-4.1.27/fs/gfs2/
H A Dfile.c1083 * gfs2_flock - acquire/release a flock lock on a file
1116 .flock = gfs2_flock,
1130 .flock = gfs2_flock,
H A Dincore.h548 unsigned int ar_localflocks:1; /* Let the VFS do flock|fcntl */
H A Dglock.c1757 "flock",
/linux-4.1.27/drivers/staging/lustre/lustre/include/
H A Dlustre_dlm.h108 * A lock has both a type (extent, flock, inode bits, or plain) and a mode.
110 * ldlm_{extent,flock,inodebits,plain}.c.
703 * Per export hash of flock locks.
H A Dlustre_dlm_flags.h117 /** flock deadlock detected */
/linux-4.1.27/fs/ocfs2/
H A Dfile.c2639 .flock = ocfs2_flock,
2657 .flock = ocfs2_flock,
2684 .flock = ocfs2_flock,
2701 .flock = ocfs2_flock,
H A Ddlmglue.c1857 * flock() calls. The locking approach this requires is sufficiently
1865 * no-lock at unlock time. This also means flock locks never go on
1868 * - Since userspace can trivially deadlock itself with flock, we make
1869 * sure to allow cancellation of a misbehaving applications flock()
1872 * - Access to any flock lockres doesn't require concurrency, so we
1874 * serialization of dlmglue flock calls.
1945 * flock(). Current behavior locally is to allow the ocfs2_file_lock()
H A Dsuper.c1391 * flock() requests, or "unbalance" existing ocfs2_parse_options()
1396 * flock structures for proper tracking of ocfs2_parse_options()
/linux-4.1.27/arch/s390/kernel/
H A Dcompat_wrapper.c114 COMPAT_SYSCALL_WRAP2(flock, unsigned int, fd, unsigned int, cmd);
/linux-4.1.27/arch/parisc/kernel/
H A Dsyscall_table.S229 ENTRY_SAME(flock)
/linux-4.1.27/drivers/staging/lustre/lustre/obdclass/
H A Dobd_mount.c1024 /* Client options are parsed in ll_options: eg. flock, lmd_parse()
1188 * @param data Mount options (e.g. -o flock,abort_recov)
/linux-4.1.27/tools/hv/
H A Dhv_kvp_daemon.c125 struct flock fl = {F_WRLCK, SEEK_SET, 0, 0, 0}; kvp_acquire_lock()
137 struct flock fl = {F_UNLCK, SEEK_SET, 0, 0, 0}; kvp_release_lock()
/linux-4.1.27/include/linux/
H A Dfs.h948 * POSIX byte range locks, BSD (flock) locks, and leases. It's important to
1015 extern int fcntl_getlk(struct file *, unsigned int, struct flock __user *);
1017 struct flock __user *);
1056 struct flock __user *user) fcntl_getlk()
1062 unsigned int cmd, struct flock __user *user) fcntl_setlk()
1612 int (*flock) (struct file *, int, struct file_lock *); member in struct:file_operations
H A Dsecurity.h623 * Note: this hook mediates both flock and fcntl style locks.
/linux-4.1.27/arch/ia64/kernel/
H A Dfsys.S673 data8 0 // flock // 1145
/linux-4.1.27/arch/alpha/kernel/
H A Dsetup.c754 * Identify the flock of penguins. setup_arch()
/linux-4.1.27/tools/perf/
H A Dbuiltin-trace.c968 { .name = "flock", .errmsg = true,
/linux-4.1.27/drivers/staging/lustre/lustre/include/lustre/
H A Dlustre_idl.h1250 #define OBD_CONNECT_FLOCK_DEAD 0x8000000000000ULL/* flock deadlock detection */

Completed in 2030 milliseconds