xref: /illumos-gate/usr/src/cmd/sendmail/db/xa/xa_map.c (revision 7c478bd9)
1 /*-
2  * See the file LICENSE for redistribution information.
3  *
4  * Copyright (c) 1996, 1997, 1998
5  *	Sleepycat Software.  All rights reserved.
6  */
7 
8 #pragma ident	"%Z%%M%	%I%	%E% SMI"
9 
10 #include "config.h"
11 
12 #ifndef lint
13 static const char sccsid[] = "@(#)xa_map.c	10.4 (Sleepycat) 10/20/98";
14 #endif /* not lint */
15 
16 #ifndef NO_SYSTEM_INCLUDES
17 #include <sys/types.h>
18 
19 #include <errno.h>
20 #include <stdio.h>
21 #include <string.h>
22 #endif
23 
24 #include "db_int.h"
25 #include "shqueue.h"
26 #include "txn.h"
27 
28 /*
29  * This file contains all the mapping information that we need to support
30  * the DB/XA interface.
31  */
32 
33 /*
34  * __db_rmid_to_env
35  *	Return the environment associated with a given XA rmid.
36  *
37  * PUBLIC: int __db_rmid_to_env __P((int rmid, DB_ENV **envp, int open_ok));
38  */
39 int
__db_rmid_to_env(rmid,envp,open_ok)40 __db_rmid_to_env(rmid, envp, open_ok)
41 	int rmid;
42 	DB_ENV **envp;
43 	int open_ok;
44 {
45 	DB_ENV *env;
46 	char *dbhome;
47 
48 	env = TAILQ_FIRST(&DB_GLOBAL(db_envq));
49 	if (env != NULL && env->xa_rmid == rmid) {
50 		*envp = env;
51 		return (0);
52 	}
53 
54 	/*
55 	 * When we map an rmid, move that environment to be the first one in
56 	 * the list of environments, so we pass the correct environment from
57 	 * the upcoming db_xa_open() call into db_open().
58 	 */
59 	for (; env != NULL; env = TAILQ_NEXT(env, links))
60 		if (env->xa_rmid == rmid) {
61 			TAILQ_REMOVE(&DB_GLOBAL(db_envq), env, links);
62 			TAILQ_INSERT_HEAD(&DB_GLOBAL(db_envq), env, links);
63 			*envp = env;
64 			return (0);
65 		}
66 
67 	/*
68 	 * We have not found the rmid on the environment list.  If we
69 	 * are allowed to do an open, search for the rmid on the name
70 	 * list and, if we find it, then open it.
71 	 */
72 	if (!open_ok)
73 		return (1);
74 
75 	if (__db_rmid_to_name(rmid, &dbhome) != 0)
76 		return (1);
77 #undef XA_FLAGS
78 #define	XA_FLAGS \
79 	DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN
80 
81 	if (__os_calloc(1, sizeof(DB_ENV), &env) != 0)
82 		return (1);
83 
84 	if (db_appinit(dbhome, NULL, env, XA_FLAGS) != 0)
85 		goto err;
86 
87 	if (__db_map_rmid(rmid, env) != 0)
88 		goto err1;
89 
90 	__db_unmap_rmid_name(rmid);
91 
92 	*envp = env;
93 	return (0);
94 
95 err1:	(void)db_appexit(env);
96 err:	__os_free(env, sizeof(DB_ENV));
97 	return (1);
98 }
99 
100 /*
101  * __db_xid_to_txn
102  *	Return the txn that corresponds to this XID.
103  *
104  * PUBLIC: int __db_xid_to_txn __P((DB_ENV *, XID *, size_t *));
105  */
106 int
__db_xid_to_txn(dbenv,xid,offp)107 __db_xid_to_txn(dbenv, xid, offp)
108 	DB_ENV *dbenv;
109 	XID *xid;
110 	size_t *offp;
111 {
112 	DB_TXNREGION *tmr;
113 	struct __txn_detail *td;
114 
115 	/*
116 	 * Search the internal active transaction table to find the
117 	 * matching xid.  If this is a performance hit, then we
118 	 * can create a hash table, but I doubt it's worth it.
119 	 */
120 	tmr = dbenv->tx_info->region;
121 
122 	LOCK_TXNREGION(dbenv->tx_info);
123 	for (td = SH_TAILQ_FIRST(&tmr->active_txn, __txn_detail);
124 	    td != NULL;
125 	    td = SH_TAILQ_NEXT(td, links, __txn_detail))
126 		if (memcmp(xid->data, td->xid, XIDDATASIZE) == 0)
127 			break;
128 	UNLOCK_TXNREGION(dbenv->tx_info);
129 
130 	if (td == NULL)
131 		return (EINVAL);
132 
133 	*offp = (u_int8_t *)td - (u_int8_t *)tmr;
134 	return (0);
135 }
136 
137 /*
138  * __db_map_rmid
139  *	Create a mapping between the specified rmid and environment.
140  *
141  * PUBLIC: int __db_map_rmid __P((int, DB_ENV *));
142  */
143 int
__db_map_rmid(rmid,env)144 __db_map_rmid(rmid, env)
145 	int rmid;
146 	DB_ENV *env;
147 {
148 	if (__os_calloc(1, sizeof(DB_TXN), &env->xa_txn) != 0)
149 		return (XAER_RMERR);
150 	env->xa_txn->txnid = TXN_INVALID;
151 	env->xa_rmid = rmid;
152 	TAILQ_INSERT_HEAD(&DB_GLOBAL(db_envq), env, links);
153 	return (XA_OK);
154 }
155 
156 /*
157  * __db_unmap_rmid
158  *	Destroy the mapping for the given rmid.
159  *
160  * PUBLIC: int __db_unmap_rmid __P((int));
161  */
162 int
__db_unmap_rmid(rmid)163 __db_unmap_rmid(rmid)
164 	int rmid;
165 {
166 	DB_ENV *e;
167 
168 	for (e = TAILQ_FIRST(&DB_GLOBAL(db_envq));
169 	    e->xa_rmid != rmid;
170 	    e = TAILQ_NEXT(e, links));
171 
172 	if (e == NULL)
173 		return (EINVAL);
174 
175 	TAILQ_REMOVE(&DB_GLOBAL(db_envq), e, links);
176 	if (e->xa_txn != NULL)
177 		__os_free(e->xa_txn, sizeof(DB_TXN));
178 	return (0);
179 }
180 
181 /*
182  * __db_map_xid
183  *	Create a mapping between this XID and the transaction at
184  *	"off" in the shared region.
185  *
186  * PUBLIC: int __db_map_xid __P((DB_ENV *, XID *, size_t));
187  */
188 int
__db_map_xid(env,xid,off)189 __db_map_xid(env, xid, off)
190 	DB_ENV *env;
191 	XID *xid;
192 	size_t off;
193 {
194 	DB_TXNMGR *tm;
195 	TXN_DETAIL *td;
196 
197 	tm = env->tx_info;
198 	td = (TXN_DETAIL *)((u_int8_t *)tm->region + off);
199 
200 	LOCK_TXNREGION(tm);
201 	memcpy(td->xid, xid->data, XIDDATASIZE);
202 	UNLOCK_TXNREGION(tm);
203 
204 	return (0);
205 }
206 
207 /*
208  * __db_unmap_xid
209  *	Destroy the mapping for the specified XID.
210  *
211  * PUBLIC: void __db_unmap_xid __P((DB_ENV *, XID *, size_t));
212  */
213 
214 void
__db_unmap_xid(env,xid,off)215 __db_unmap_xid(env, xid, off)
216 	DB_ENV *env;
217 	XID *xid;
218 	size_t off;
219 {
220 	TXN_DETAIL *td;
221 
222 	COMPQUIET(xid, NULL);
223 
224 	td = (TXN_DETAIL *)((u_int8_t *)env->tx_info->region + off);
225 	memset(td->xid, 0, sizeof(td->xid));
226 }
227 
228 /*
229  * __db_map_rmid_name --
230  * 	Create a mapping from an rmid to a name (the xa_info argument).
231  * We use this during create and then at some later point when we are
232  * trying to map an rmid, we might indicate that it's OK to do an open
233  * in which case, we'll get the xa_info parameter from here and then
234  * free it up.
235  *
236  * PUBLIC: int __db_map_rmid_name __P((int, char *));
237  */
238 
239 int
__db_map_rmid_name(rmid,dbhome)240 __db_map_rmid_name(rmid, dbhome)
241 	int rmid;
242 	char *dbhome;
243 {
244 	struct __rmname *entry;
245 	int ret;
246 
247 	if ((ret = __os_malloc(sizeof(struct __rmname), NULL, &entry)) != 0)
248 		return (ret);
249 
250 	if ((ret = __os_strdup(dbhome, &entry->dbhome)) != 0) {
251 		__os_free(entry, sizeof(struct __rmname));
252 		return (ret);
253 	}
254 
255 	entry->rmid = rmid;
256 
257 	TAILQ_INSERT_HEAD(&DB_GLOBAL(db_nameq), entry, links);
258 	return (0);
259 }
260 
261 /*
262  * __db_rmid_to_name --
263  *	Given an rmid, return the name of the home directory for that
264  * rmid.
265  *
266  * PUBLIC: int __db_rmid_to_name __P((int, char **));
267  */
268 int
__db_rmid_to_name(rmid,dbhomep)269 __db_rmid_to_name(rmid, dbhomep)
270 	int rmid;
271 	char **dbhomep;
272 {
273 	struct __rmname *np;
274 
275 	for (np = TAILQ_FIRST(&DB_GLOBAL(db_nameq)); np != NULL;
276 	    np = TAILQ_NEXT(np, links)) {
277 		if (np->rmid == rmid) {
278 			*dbhomep = np->dbhome;
279 			return (0);
280 		}
281 	}
282 	return (1);
283 }
284 
285 /*
286  * __db_unmap_rmid_name --
287  *	Given an rmid, remove its entry from the name list.
288  *
289  * PUBLIC:  void __db_unmap_rmid_name __P((int));
290  */
291 void
__db_unmap_rmid_name(rmid)292 __db_unmap_rmid_name(rmid)
293 	int rmid;
294 {
295 	struct __rmname *np, *next;
296 
297 	for (np = TAILQ_FIRST(&DB_GLOBAL(db_nameq)); np != NULL; np = next) {
298 		next = TAILQ_NEXT(np, links);
299 		if (np->rmid == rmid) {
300 			TAILQ_REMOVE(&DB_GLOBAL(db_nameq), np, links);
301 			__os_freestr(np->dbhome);
302 			__os_free(np, sizeof(struct __rmname));
303 			return;
304 		}
305 	}
306 	return;
307 }
308