1/*-
2 * See the file LICENSE for redistribution information.
3 *
4 * Copyright (c) 1996-2009 Oracle.  All rights reserved.
5 *
6 * $Id$
7 */
8
9#include "db_config.h"
10
11#include "db_int.h"
12#include "dbinc/lock.h"
13
14/*
15 * If the library wasn't compiled with locking support, various routines
16 * aren't available.  Stub them here, returning an appropriate error.
17 */
18static int __db_nolocking __P((ENV *));
19
20/*
21 * __db_nolocking --
22 *	Error when a Berkeley DB build doesn't include the locking subsystem.
23 */
24static int
25__db_nolocking(env)
26	ENV *env;
27{
28	__db_errx(env, "library build did not include support for locking");
29	return (DB_OPNOTSUP);
30}
31
32int
33__lock_env_create(dbenv)
34	DB_ENV *dbenv;
35{
36	COMPQUIET(dbenv, 0);
37	return (0);
38}
39
40void
41__lock_env_destroy(dbenv)
42	DB_ENV *dbenv;
43{
44	COMPQUIET(dbenv, 0);
45}
46
47int
48__lock_get_lk_conflicts(dbenv, lk_conflictsp, lk_modesp)
49	DB_ENV *dbenv;
50	const u_int8_t **lk_conflictsp;
51	int *lk_modesp;
52{
53	COMPQUIET(lk_conflictsp, NULL);
54	COMPQUIET(lk_modesp, NULL);
55	return (__db_nolocking(dbenv->env));
56}
57
58int
59__lock_get_lk_detect(dbenv, lk_detectp)
60	DB_ENV *dbenv;
61	u_int32_t *lk_detectp;
62{
63	COMPQUIET(lk_detectp, NULL);
64	return (__db_nolocking(dbenv->env));
65}
66
67int
68__lock_get_lk_max_lockers(dbenv, lk_maxp)
69	DB_ENV *dbenv;
70	u_int32_t *lk_maxp;
71{
72	COMPQUIET(lk_maxp, NULL);
73	return (__db_nolocking(dbenv->env));
74}
75
76int
77__lock_get_lk_max_locks(dbenv, lk_maxp)
78	DB_ENV *dbenv;
79	u_int32_t *lk_maxp;
80{
81	COMPQUIET(lk_maxp, NULL);
82	return (__db_nolocking(dbenv->env));
83}
84
85int
86__lock_get_lk_max_objects(dbenv, lk_maxp)
87	DB_ENV *dbenv;
88	u_int32_t *lk_maxp;
89{
90	COMPQUIET(lk_maxp, NULL);
91	return (__db_nolocking(dbenv->env));
92}
93
94int
95__lock_get_lk_partitions(dbenv, lk_maxp)
96	DB_ENV *dbenv;
97	u_int32_t *lk_maxp;
98{
99	COMPQUIET(lk_maxp, NULL);
100	return (__db_nolocking(dbenv->env));
101}
102
103int
104__lock_get_env_timeout(dbenv, timeoutp, flag)
105	DB_ENV *dbenv;
106	db_timeout_t *timeoutp;
107	u_int32_t flag;
108{
109	COMPQUIET(timeoutp, NULL);
110	COMPQUIET(flag, 0);
111	return (__db_nolocking(dbenv->env));
112}
113
114int
115__lock_detect_pp(dbenv, flags, atype, abortp)
116	DB_ENV *dbenv;
117	u_int32_t flags, atype;
118	int *abortp;
119{
120	COMPQUIET(flags, 0);
121	COMPQUIET(atype, 0);
122	COMPQUIET(abortp, NULL);
123	return (__db_nolocking(dbenv->env));
124}
125
126int
127__lock_get_pp(dbenv, locker, flags, obj, lock_mode, lock)
128	DB_ENV *dbenv;
129	u_int32_t locker, flags;
130	DBT *obj;
131	db_lockmode_t lock_mode;
132	DB_LOCK *lock;
133{
134	COMPQUIET(locker, 0);
135	COMPQUIET(flags, 0);
136	COMPQUIET(obj, NULL);
137	COMPQUIET(lock_mode, 0);
138	COMPQUIET(lock, NULL);
139	return (__db_nolocking(dbenv->env));
140}
141
142int
143__lock_id_pp(dbenv, idp)
144	DB_ENV *dbenv;
145	u_int32_t *idp;
146{
147	COMPQUIET(idp, NULL);
148	return (__db_nolocking(dbenv->env));
149}
150
151int
152__lock_id_free_pp(dbenv, id)
153	DB_ENV *dbenv;
154	u_int32_t id;
155{
156	COMPQUIET(id, 0);
157	return (__db_nolocking(dbenv->env));
158}
159
160int
161__lock_put_pp(dbenv, lock)
162	DB_ENV *dbenv;
163	DB_LOCK *lock;
164{
165	COMPQUIET(lock, NULL);
166	return (__db_nolocking(dbenv->env));
167}
168
169int
170__lock_stat_pp(dbenv, statp, flags)
171	DB_ENV *dbenv;
172	DB_LOCK_STAT **statp;
173	u_int32_t flags;
174{
175	COMPQUIET(statp, NULL);
176	COMPQUIET(flags, 0);
177	return (__db_nolocking(dbenv->env));
178}
179
180int
181__lock_stat_print_pp(dbenv, flags)
182	DB_ENV *dbenv;
183	u_int32_t flags;
184{
185	COMPQUIET(flags, 0);
186	return (__db_nolocking(dbenv->env));
187}
188
189int
190__lock_vec_pp(dbenv, locker, flags, list, nlist, elistp)
191	DB_ENV *dbenv;
192	u_int32_t locker, flags;
193	int nlist;
194	DB_LOCKREQ *list, **elistp;
195{
196	COMPQUIET(locker, 0);
197	COMPQUIET(flags, 0);
198	COMPQUIET(list, NULL);
199	COMPQUIET(nlist, 0);
200	COMPQUIET(elistp, NULL);
201	return (__db_nolocking(dbenv->env));
202}
203
204int
205__lock_set_lk_conflicts(dbenv, lk_conflicts, lk_modes)
206	DB_ENV *dbenv;
207	u_int8_t *lk_conflicts;
208	int lk_modes;
209{
210	COMPQUIET(lk_conflicts, NULL);
211	COMPQUIET(lk_modes, 0);
212	return (__db_nolocking(dbenv->env));
213}
214
215int
216__lock_set_lk_detect(dbenv, lk_detect)
217	DB_ENV *dbenv;
218	u_int32_t lk_detect;
219{
220	COMPQUIET(lk_detect, 0);
221	return (__db_nolocking(dbenv->env));
222}
223
224int
225__lock_set_lk_max_locks(dbenv, lk_max)
226	DB_ENV *dbenv;
227	u_int32_t lk_max;
228{
229	COMPQUIET(lk_max, 0);
230	return (__db_nolocking(dbenv->env));
231}
232
233int
234__lock_set_lk_max_lockers(dbenv, lk_max)
235	DB_ENV *dbenv;
236	u_int32_t lk_max;
237{
238	COMPQUIET(lk_max, 0);
239	return (__db_nolocking(dbenv->env));
240}
241
242int
243__lock_set_lk_max_objects(dbenv, lk_max)
244	DB_ENV *dbenv;
245	u_int32_t lk_max;
246{
247	COMPQUIET(lk_max, 0);
248	return (__db_nolocking(dbenv->env));
249}
250
251int
252__lock_set_lk_partitions(dbenv, lk_max)
253	DB_ENV *dbenv;
254	u_int32_t lk_max;
255{
256	COMPQUIET(lk_max, 0);
257	return (__db_nolocking(dbenv->env));
258}
259
260int
261__lock_set_env_timeout(dbenv, timeout, flags)
262	DB_ENV *dbenv;
263	db_timeout_t timeout;
264	u_int32_t flags;
265{
266	COMPQUIET(timeout, 0);
267	COMPQUIET(flags, 0);
268	return (__db_nolocking(dbenv->env));
269}
270
271int
272__lock_open(env, create_ok)
273	ENV *env;
274	int create_ok;
275{
276	COMPQUIET(create_ok, 0);
277	return (__db_nolocking(env));
278}
279
280int
281__lock_id_free(env, sh_locker)
282	ENV *env;
283	DB_LOCKER *sh_locker;
284{
285	COMPQUIET(env, NULL);
286	COMPQUIET(sh_locker, 0);
287	return (0);
288}
289
290int
291__lock_env_refresh(env)
292	ENV *env;
293{
294	COMPQUIET(env, NULL);
295	return (0);
296}
297
298int
299__lock_stat_print(env, flags)
300	ENV *env;
301	u_int32_t flags;
302{
303	COMPQUIET(env, NULL);
304	COMPQUIET(flags, 0);
305	return (0);
306}
307
308int
309__lock_put(env, lock)
310	ENV *env;
311	DB_LOCK *lock;
312{
313	COMPQUIET(env, NULL);
314	COMPQUIET(lock, NULL);
315	return (0);
316}
317
318int
319__lock_vec(env, sh_locker, flags, list, nlist, elistp)
320	ENV *env;
321	DB_LOCKER *sh_locker;
322	u_int32_t flags;
323	int nlist;
324	DB_LOCKREQ *list, **elistp;
325{
326	COMPQUIET(env, NULL);
327	COMPQUIET(sh_locker, 0);
328	COMPQUIET(flags, 0);
329	COMPQUIET(list, NULL);
330	COMPQUIET(nlist, 0);
331	COMPQUIET(elistp, NULL);
332	return (0);
333}
334
335int
336__lock_get(env, locker, flags, obj, lock_mode, lock)
337	ENV *env;
338	DB_LOCKER *locker;
339	u_int32_t flags;
340	const DBT *obj;
341	db_lockmode_t lock_mode;
342	DB_LOCK *lock;
343{
344	COMPQUIET(env, NULL);
345	COMPQUIET(locker, NULL);
346	COMPQUIET(flags, 0);
347	COMPQUIET(obj, NULL);
348	COMPQUIET(lock_mode, 0);
349	COMPQUIET(lock, NULL);
350	return (0);
351}
352
353int
354__lock_id(env, idp, lkp)
355	ENV *env;
356	u_int32_t *idp;
357	DB_LOCKER **lkp;
358{
359	COMPQUIET(env, NULL);
360	COMPQUIET(idp, NULL);
361	COMPQUIET(lkp, NULL);
362	return (0);
363}
364
365int
366__lock_inherit_timeout(env, parent, locker)
367	ENV *env;
368	DB_LOCKER *parent, *locker;
369{
370	COMPQUIET(env, NULL);
371	COMPQUIET(parent, NULL);
372	COMPQUIET(locker, NULL);
373	return (0);
374}
375
376int
377__lock_set_timeout(env, locker, timeout, op)
378	ENV *env;
379	DB_LOCKER *locker;
380	db_timeout_t timeout;
381	u_int32_t op;
382{
383	COMPQUIET(env, NULL);
384	COMPQUIET(locker, NULL);
385	COMPQUIET(timeout, 0);
386	COMPQUIET(op, 0);
387	return (0);
388}
389
390int
391__lock_addfamilylocker(env, pid, id)
392	ENV *env;
393	u_int32_t pid, id;
394{
395	COMPQUIET(env, NULL);
396	COMPQUIET(pid, 0);
397	COMPQUIET(id, 0);
398	return (0);
399}
400
401int
402__lock_freefamilylocker(lt, sh_locker)
403	DB_LOCKTAB *lt;
404	DB_LOCKER *sh_locker;
405{
406	COMPQUIET(lt, NULL);
407	COMPQUIET(sh_locker, NULL);
408	return (0);
409}
410
411int
412__lock_downgrade(env, lock, new_mode, flags)
413	ENV *env;
414	DB_LOCK *lock;
415	db_lockmode_t new_mode;
416	u_int32_t flags;
417{
418	COMPQUIET(env, NULL);
419	COMPQUIET(lock, NULL);
420	COMPQUIET(new_mode, 0);
421	COMPQUIET(flags, 0);
422	return (0);
423}
424
425int
426__lock_locker_is_parent(env, locker, child, retp)
427	ENV *env;
428	DB_LOCKER *locker;
429	DB_LOCKER *child;
430	int *retp;
431{
432	COMPQUIET(env, NULL);
433	COMPQUIET(locker, NULL);
434	COMPQUIET(child, NULL);
435
436	*retp = 1;
437	return (0);
438}
439
440void
441__lock_set_thread_id(lref, pid, tid)
442	void *lref;
443	pid_t pid;
444	db_threadid_t tid;
445{
446	COMPQUIET(lref, NULL);
447	COMPQUIET(pid, 0);
448	COMPQUIET(tid, 0);
449}
450
451int
452__lock_failchk(env)
453	ENV *env;
454{
455	COMPQUIET(env, NULL);
456	return (0);
457}
458
459int
460__lock_get_list(env, locker, flags, lock_mode, list)
461	ENV *env;
462	DB_LOCKER *locker;
463	u_int32_t flags;
464	db_lockmode_t lock_mode;
465	DBT *list;
466{
467	COMPQUIET(env, NULL);
468	COMPQUIET(locker, NULL);
469	COMPQUIET(flags, 0);
470	COMPQUIET(lock_mode, 0);
471	COMPQUIET(list, NULL);
472	return (0);
473}
474
475void
476__lock_list_print(env, list)
477	ENV *env;
478	DBT *list;
479{
480	COMPQUIET(env, NULL);
481	COMPQUIET(list, NULL);
482}
483
484int
485__lock_getlocker(lt, locker, create, retp)
486	DB_LOCKTAB *lt;
487	u_int32_t locker;
488	int create;
489	DB_LOCKER **retp;
490{
491	COMPQUIET(locker, 0);
492	COMPQUIET(create, 0);
493	COMPQUIET(retp, NULL);
494	return (__db_nolocking(lt->env));
495}
496
497int
498__lock_id_set(env, cur_id, max_id)
499	ENV *env;
500	u_int32_t cur_id, max_id;
501{
502	COMPQUIET(env, NULL);
503	COMPQUIET(cur_id, 0);
504	COMPQUIET(max_id, 0);
505	return (0);
506}
507