xref: /titanic_41/usr/src/uts/common/sys/flock.h (revision c04062bdc8dc59c4474832b0ca88e697ead10df2)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
23 /*	  All Rights Reserved  	*/
24 
25 
26 /*
27  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
28  * Use is subject to license terms.
29  */
30 /*
31  * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
32  */
33 
34 #ifndef _SYS_FLOCK_H
35 #define	_SYS_FLOCK_H
36 
37 #include <sys/types.h>
38 #include <sys/fcntl.h>
39 #include <sys/vnode.h>
40 #include <sys/t_lock.h>		/* for <sys/callb.h> */
41 #include <sys/callb.h>
42 #include <sys/param.h>
43 #include <sys/zone.h>
44 
45 #ifdef	__cplusplus
46 extern "C" {
47 #endif
48 
49 /*
50  * Private declarations and instrumentation for local locking.
51  */
52 
53 /*
54  * The flag passed to fs_frlock() may be ORed together with either
55  * `F_REMOTELOCK' or `F_PXFSLOCK'.  Since this flag is initialized using the
56  * `f_flag' field in the `file' structure, and that field is an unsigned short,
57  * we do not use the first 2 bytes.
58  */
59 #define	F_REMOTELOCK	(0x01 << 16) /* Set if NLM lock */
60 #define	F_PXFSLOCK	(0x02 << 16) /* Clustering: set if PXFS lock */
61 
62 /*
63  * The command passed to reclock() is made by ORing together one or more of
64  * the following values.
65  */
66 
67 #define	INOFLCK		0x01	/* Vnode is locked when reclock() is called. */
68 #define	SETFLCK		0x02	/* Set a file lock. */
69 #define	SLPFLCK		0x04	/* Wait if blocked. */
70 #define	RCMDLCK		0x08	/* F_REMOTELOCK specified */
71 #define	PCMDLCK		0x10	/* Clustering: F_PXFSLOCK specified */
72 #define	NBMLCK		0x20	/* non-blocking mandatory locking */
73 
74 /*
75  * Special pid value that can be passed to cleanlocks().  It means that
76  * cleanlocks() should flush all locks for the given sysid, not just the
77  * locks owned by a specific process.
78  */
79 
80 #define	IGN_PID		(-1)
81 
82 /* file locking structure (connected to vnode) */
83 
84 #define	l_end		l_len
85 
86 /*
87  * The lock manager is allowed to use unsigned offsets and lengths, though
88  * regular Unix processes are still required to use signed offsets and
89  * lengths.
90  */
91 typedef ulong_t u_off_t;
92 
93 #define	MAX_U_OFF_T	((u_off_t)~0)
94 #define	MAX_U_OFFSET_T	((u_offset_t)~0)
95 
96 /*
97  * define MAXEND as the largest positive value the signed offset_t will hold.
98  */
99 #define	MAXEND		MAXOFFSET_T
100 
101 /*
102  * Definitions for accessing the l_pad area of struct flock.  The
103  * descriminant of the pad_info_t union is the fcntl command used in
104  * conjunction with the flock struct.
105  */
106 
107 typedef union {
108 	int	pi_pad[4];		/* (original pad area) */
109 	int	pi_has_rmt;		/* F_HASREMOTELOCKS */
110 } pad_info_t;
111 
112 #define	l_has_rmt(flockp)	(((pad_info_t *)((flockp)->l_pad))->pi_has_rmt)
113 
114 /*
115  * Optional callbacks for blocking lock requests.  Each function is called
116  * twice.
117  * The first call is after the request is put in the "sleeping" list, but
118  *   before waiting.  At most one callback may return a callb_cpr_t object;
119  *   the others must return NULL.  If a callb_cpr_t is returned, the thread
120  *   will be marked as safe to suspend while waiting for the lock.
121  * The second call is after the request wakes up.  Note that the request
122  *   might not have been granted at the second call (e.g., the request was
123  *   signalled).
124  * New callbacks should be added to the head of the list.  For the first
125  * call the list is walked in order.  For the second call the list is
126  * walked backwards (in case the callbacks need to reacquire locks).
127  */
128 
129 typedef enum {FLK_BEFORE_SLEEP, FLK_AFTER_SLEEP} flk_cb_when_t;
130 
131 struct flk_callback {
132 	struct flk_callback *cb_next;	/* circular linked list */
133 	struct flk_callback *cb_prev;
134 	callb_cpr_t	*(*cb_callback)(flk_cb_when_t, void *);	/* fcn ptr */
135 	void		*cb_data;	/* ptr to callback data */
136 };
137 
138 typedef struct flk_callback flk_callback_t;
139 
140 /*
141  * This structure members are not used any more inside the kernel.
142  * The structure is used for casting some pointer assignments only.
143  */
144 
145 typedef struct filock {
146 	kcondvar_t cv;
147 	struct	flock set;	/* contains type, start, and end */
148 	struct	{
149 		int granted_flag;	/* granted flag */
150 		struct filock *blk;	/* for sleeping locks only */
151 		struct attacher *blocking_list;
152 		struct attacher *my_attacher;
153 	}	stat;
154 	struct	filock *prev;
155 	struct	filock *next;
156 } filock_t;
157 
158 #define	FLP_DELAYED_FREE	-1	/* special value for granted_flag */
159 
160 /* structure that contains list of locks to be granted */
161 
162 #define	MAX_GRANT_LOCKS		52
163 
164 typedef struct grant_lock {
165 	struct filock *grant_lock_list[MAX_GRANT_LOCKS];
166 	struct grant_lock *next;
167 } grant_lock_t;
168 
169 /*
170  * Provide a way to cleanly enable and disable Network Lock Manager locking
171  * requests (i.e., requests from remote clients):
172  *    FLK_NLM_SHUTTING_DOWN: Forces all blocked NLM requests to bail out
173  *	and return ENOLCK.
174  *    FLK_NLM_DOWN: Clears all granted NLM server locks.  Both status
175  *	codes cause new NLM lock requests to fail immediately with ENOLCK.
176  *    FLK_NLM_UP: Changes the state of all locks to UP, after a server has
177  *	shutdown and is restarting on the same node.
178  */
179 
180 /*
181  * Enumerated type of the four possible states an NLM server can be in.
182  */
183 typedef enum {
184 	FLK_NLM_UP,
185 	FLK_NLM_SHUTTING_DOWN,
186 	FLK_NLM_DOWN,
187 	FLK_NLM_UNKNOWN
188 } flk_nlm_status_t;
189 
190 /*
191  * Provide a way to cleanly enable and disable lock manager locking
192  * requests (i.e., requests from remote clients).  FLK_WAKEUP_SLEEPERS
193  * forces all blocked lock manager requests to bail out and return ENOLCK.
194  * FLK_LOCKMGR_DOWN clears all granted lock manager locks.  Both status
195  * codes cause new lock manager requests to fail immediately with ENOLCK.
196  */
197 
198 typedef enum {
199     FLK_LOCKMGR_UP,
200     FLK_WAKEUP_SLEEPERS,
201     FLK_LOCKMGR_DOWN
202 } flk_lockmgr_status_t;
203 
204 #if defined(_KERNEL) || defined(_FAKE_KERNEL)
205 
206 /*
207  * The following structure is used to hold a list of locks returned
208  * by the F_ACTIVELIST or F_SLEEPINGLIST commands to fs_frlock.
209  *
210  * N.B. The lists returned by these commands are dynamically
211  * allocated and must be freed by the caller.  The vnodes returned
212  * in the lists are held and must be released when the caller is done.
213  */
214 
215 typedef struct locklist {
216 	struct vnode *ll_vp;
217 	struct flock64 ll_flock;
218 	struct locklist *ll_next;
219 } locklist_t;
220 
221 #define	FLK_QUERY_ACTIVE	0x1
222 #define	FLK_QUERY_SLEEPING	0x2
223 
224 int	reclock(struct vnode *, struct flock64 *, int, int, u_offset_t,
225 		flk_callback_t *);
226 int	chklock(struct vnode *, int, u_offset_t, ssize_t, int,
227 		caller_context_t *);
228 int	convoff(struct vnode *, struct flock64 *, int, offset_t);
229 void	cleanlocks(struct vnode *, pid_t, int);
230 locklist_t *flk_get_sleeping_locks(int sysid, pid_t pid);
231 locklist_t *flk_get_active_locks(int sysid, pid_t pid);
232 locklist_t *flk_active_locks_for_vp(const struct vnode *vp);
233 locklist_t *flk_active_nbmand_locks_for_vp(const struct vnode *vp);
234 locklist_t *flk_active_nbmand_locks(pid_t pid);
235 void	flk_free_locklist(locklist_t *);
236 int	flk_convert_lock_data(struct vnode *, struct flock64 *,
237 		u_offset_t *, u_offset_t *, offset_t);
238 int	flk_check_lock_data(u_offset_t, u_offset_t, offset_t);
239 int	flk_has_remote_locks(struct vnode *vp);
240 void	flk_set_lockmgr_status(flk_lockmgr_status_t status);
241 int	flk_sysid_has_locks(int sysid, int chklck);
242 int	flk_has_remote_locks_for_sysid(vnode_t *vp, int);
243 void	flk_init_callback(flk_callback_t *,
244 		callb_cpr_t *(*)(flk_cb_when_t, void *), void *);
245 void	flk_add_callback(flk_callback_t *,
246 		callb_cpr_t *(*)(flk_cb_when_t, void *), void *,
247 		flk_callback_t *);
248 void	flk_del_callback(flk_callback_t *);
249 callb_cpr_t *flk_invoke_callbacks(flk_callback_t *, flk_cb_when_t);
250 
251 /* Zones hooks */
252 extern	zone_key_t flock_zone_key;
253 
254 void	*flk_zone_init(zoneid_t);
255 void	flk_zone_fini(zoneid_t, void *);
256 
257 /* Clustering hooks */
258 void	cl_flk_set_nlm_status(int nlmid, flk_nlm_status_t nlm_state);
259 void	cl_flk_remove_locks_by_sysid(int sysid);
260 int	cl_flk_has_remote_locks_for_nlmid(struct vnode *vp, int nlmid);
261 void	cl_flk_change_nlm_state_to_unknown(int nlmid);
262 void	cl_flk_delete_pxfs_locks(struct vfs *vfsp, int pxfsid);
263 #endif /* _KERNEL */
264 
265 #ifdef	__cplusplus
266 }
267 #endif
268 
269 #endif	/* _SYS_FLOCK_H */
270