flock.h revision 7a5aac98bc37534537d4896efd4efd30627d221e
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright 2013 Nexenta Systems, Inc. All rights reserved.
* Copyright 2015 Joyent, Inc.
*/
#ifndef _SYS_FLOCK_H
#define _SYS_FLOCK_H
#include <sys/types.h>
#include <sys/fcntl.h>
#include <sys/vnode.h>
#include <sys/t_lock.h> /* for <sys/callb.h> */
#include <sys/callb.h>
#include <sys/param.h>
#include <sys/zone.h>
#if defined(_KERNEL)
#include <sys/file.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/*
* Private declarations and instrumentation for local locking.
*/
/*
* The flag passed to fs_frlock() may be ORed together with either
* `F_REMOTELOCK' or `F_PXFSLOCK'. Since this flag is initialized using the
* `f_flag' field in the `file' structure, and that field is an unsigned short,
* we do not use the first 2 bytes.
*/
#define F_REMOTELOCK (0x01 << 16) /* Set if NLM lock */
#define F_PXFSLOCK (0x02 << 16) /* Clustering: set if PXFS lock */
/*
* The command passed to reclock() is made by ORing together one or more of
* the following values.
*/
#define INOFLCK 0x01 /* Vnode is locked when reclock() is called. */
#define SETFLCK 0x02 /* Set a file lock. */
#define SLPFLCK 0x04 /* Wait if blocked. */
#define RCMDLCK 0x08 /* F_REMOTELOCK specified */
#define PCMDLCK 0x10 /* Clustering: F_PXFSLOCK specified */
#define NBMLCK 0x20 /* non-blocking mandatory locking */
/*
* Special pid value that can be passed to cleanlocks(). It means that
* cleanlocks() should flush all locks for the given sysid, not just the
* locks owned by a specific process.
*/
#define IGN_PID (-1)
/* file locking structure (connected to vnode) */
#define l_end l_len
/*
* The lock manager is allowed to use unsigned offsets and lengths, though
* regular Unix processes are still required to use signed offsets and
* lengths.
*/
typedef ulong_t u_off_t;
#define MAX_U_OFF_T ((u_off_t)~0)
#define MAX_U_OFFSET_T ((u_offset_t)~0)
/*
* define MAXEND as the largest positive value the signed offset_t will hold.
*/
#define MAXEND MAXOFFSET_T
/*
* Definitions for accessing the l_pad area of struct flock. The
* descriminant of the pad_info_t union is the fcntl command used in
* conjunction with the flock struct.
*/
typedef union {
int pi_pad[4]; /* (original pad area) */
int pi_has_rmt; /* F_HASREMOTELOCKS */
} pad_info_t;
#define l_has_rmt(flockp) (((pad_info_t *)((flockp)->l_pad))->pi_has_rmt)
/*
* Optional callbacks for blocking lock requests. Each function is called
* twice.
* The first call is after the request is put in the "sleeping" list, but
* before waiting. At most one callback may return a callb_cpr_t object;
* the others must return NULL. If a callb_cpr_t is returned, the thread
* will be marked as safe to suspend while waiting for the lock.
* The second call is after the request wakes up. Note that the request
* might not have been granted at the second call (e.g., the request was
* signalled).
* New callbacks should be added to the head of the list. For the first
* call the list is walked in order. For the second call the list is
* walked backwards (in case the callbacks need to reacquire locks).
*/
typedef enum {FLK_BEFORE_SLEEP, FLK_AFTER_SLEEP} flk_cb_when_t;
struct flk_callback {
struct flk_callback *cb_next; /* circular linked list */
struct flk_callback *cb_prev;
callb_cpr_t *(*cb_callback)(flk_cb_when_t, void *); /* fcn ptr */
void *cb_data; /* ptr to callback data */
};
typedef struct flk_callback flk_callback_t;
/*
* This structure members are not used any more inside the kernel.
* The structure is used for casting some pointer assignments only.
*/
typedef struct filock {
kcondvar_t cv;
struct flock set; /* contains type, start, and end */
struct {
int granted_flag; /* granted flag */
struct filock *blk; /* for sleeping locks only */
struct attacher *blocking_list;
struct attacher *my_attacher;
} stat;
struct filock *prev;
struct filock *next;
} filock_t;
#define FLP_DELAYED_FREE -1 /* special value for granted_flag */
/* structure that contains list of locks to be granted */
#define MAX_GRANT_LOCKS 52
typedef struct grant_lock {
struct filock *grant_lock_list[MAX_GRANT_LOCKS];
struct grant_lock *next;
} grant_lock_t;
/*
* Provide a way to cleanly enable and disable Network Lock Manager locking
* requests (i.e., requests from remote clients):
* FLK_NLM_SHUTTING_DOWN: Forces all blocked NLM requests to bail out
* and return ENOLCK.
* FLK_NLM_DOWN: Clears all granted NLM server locks. Both status
* codes cause new NLM lock requests to fail immediately with ENOLCK.
* FLK_NLM_UP: Changes the state of all locks to UP, after a server has
* shutdown and is restarting on the same node.
*/
/*
* Enumerated type of the four possible states an NLM server can be in.
*/
typedef enum {
FLK_NLM_UP,
FLK_NLM_SHUTTING_DOWN,
FLK_NLM_DOWN,
FLK_NLM_UNKNOWN
} flk_nlm_status_t;
/*
* Provide a way to cleanly enable and disable lock manager locking
* requests (i.e., requests from remote clients). FLK_WAKEUP_SLEEPERS
* forces all blocked lock manager requests to bail out and return ENOLCK.
* FLK_LOCKMGR_DOWN clears all granted lock manager locks. Both status
* codes cause new lock manager requests to fail immediately with ENOLCK.
*/
typedef enum {
FLK_LOCKMGR_UP,
FLK_WAKEUP_SLEEPERS,
FLK_LOCKMGR_DOWN
} flk_lockmgr_status_t;
#if defined(_KERNEL) || defined(_FAKE_KERNEL)
/*
* The following structure is used to hold a list of locks returned
* by the F_ACTIVELIST or F_SLEEPINGLIST commands to fs_frlock.
*
* N.B. The lists returned by these commands are dynamically
* allocated and must be freed by the caller. The vnodes returned
* in the lists are held and must be released when the caller is done.
*/
typedef struct locklist {
struct vnode *ll_vp;
struct flock64 ll_flock;
struct locklist *ll_next;
} locklist_t;
#define FLK_QUERY_ACTIVE 0x1
#define FLK_QUERY_SLEEPING 0x2
#if defined(_KERNEL)
int ofdlock(file_t *, int, struct flock64 *, int, u_offset_t);
void ofdcleanlock(file_t *);
#endif
int reclock(struct vnode *, struct flock64 *, int, int, u_offset_t,
flk_callback_t *);
int chklock(struct vnode *, int, u_offset_t, ssize_t, int,
caller_context_t *);
int convoff(struct vnode *, struct flock64 *, int, offset_t);
void cleanlocks(struct vnode *, pid_t, int);
locklist_t *flk_get_sleeping_locks(int sysid, pid_t pid);
locklist_t *flk_get_active_locks(int sysid, pid_t pid);
locklist_t *flk_active_locks_for_vp(const struct vnode *vp);
locklist_t *flk_active_nbmand_locks_for_vp(const struct vnode *vp);
locklist_t *flk_active_nbmand_locks(pid_t pid);
void flk_free_locklist(locklist_t *);
int flk_convert_lock_data(struct vnode *, struct flock64 *,
u_offset_t *, u_offset_t *, offset_t);
int flk_check_lock_data(u_offset_t, u_offset_t, offset_t);
int flk_has_remote_locks(struct vnode *vp);
void flk_set_lockmgr_status(flk_lockmgr_status_t status);
int flk_sysid_has_locks(int sysid, int chklck);
int flk_has_remote_locks_for_sysid(vnode_t *vp, int);
void flk_init_callback(flk_callback_t *,
callb_cpr_t *(*)(flk_cb_when_t, void *), void *);
void flk_add_callback(flk_callback_t *,
callb_cpr_t *(*)(flk_cb_when_t, void *), void *,
flk_callback_t *);
callb_cpr_t *flk_invoke_callbacks(flk_callback_t *, flk_cb_when_t);
/* Zones hooks */
extern zone_key_t flock_zone_key;
void *flk_zone_init(zoneid_t);
void flk_zone_fini(zoneid_t, void *);
/* Clustering hooks */
void cl_flk_set_nlm_status(int nlmid, flk_nlm_status_t nlm_state);
void cl_flk_remove_locks_by_sysid(int sysid);
int cl_flk_has_remote_locks_for_nlmid(struct vnode *vp, int nlmid);
void cl_flk_change_nlm_state_to_unknown(int nlmid);
void cl_flk_delete_pxfs_locks(struct vfs *vfsp, int pxfsid);
#endif /* _KERNEL */
#ifdef __cplusplus
}
#endif
#endif /* _SYS_FLOCK_H */