env_method.c

Go to the documentation of this file.
00001 /*-
00002  * See the file LICENSE for redistribution information.
00003  *
00004  * Copyright (c) 1999, 2000
00005  *      Sleepycat Software.  All rights reserved.
00006  */
00007 
00008 #include "config.h"
00009 
00010 #ifndef lint
00011 static const char revid[] = "$Id: env__method_8c-source.html,v 1.1 2008/06/08 10:18:39 sebdiaz Exp $";
00012 #endif /* not lint */
00013 
00014 #ifndef NO_SYSTEM_INCLUDES
00015 #include <sys/types.h>
00016 
00017 #include <errno.h>
00018 #include <string.h>
00019 #endif
00020 
00021 #ifdef HAVE_RPC
00022 #include "db_server.h"
00023 #endif
00024 
00025 /*
00026  * This is the file that initializes the global array.  Do it this way because
00027  * people keep changing one without changing the other.  Having declaration and
00028  * initialization in one file will hopefully fix that.
00029  */
00030 #define DB_INITIALIZE_DB_GLOBALS        1
00031 
00032 #include "db_int.h"
00033 #include "db_shash.h"
00034 #include "db_page.h"
00035 #include "db_am.h"
00036 #include "lock.h"
00037 #include "log.h"
00038 #include "mp.h"
00039 #include "txn.h"
00040 
00041 #ifdef HAVE_RPC
00042 #include "gen_client_ext.h"
00043 #include "rpc_client_ext.h"
00044 #endif
00045 
00046 static void __dbenv_err __P((const DB_ENV *, int, const char *, ...));
00047 static void __dbenv_errx __P((const DB_ENV *, const char *, ...));
00048 static int  __dbenv_set_data_dir __P((DB_ENV *, const char *));
00049 static void __dbenv_set_errcall __P((DB_ENV *, void (*)(const char *, char *)));
00050 static void __dbenv_set_errfile __P((DB_ENV *, FILE *));
00051 static void __dbenv_set_errpfx __P((DB_ENV *, const char *));
00052 static int  __dbenv_set_feedback __P((DB_ENV *, void (*)(DB_ENV *, int, int)));
00053 static int  __dbenv_set_paniccall __P((DB_ENV *, void (*)(DB_ENV *, int)));
00054 static int  __dbenv_set_recovery_init __P((DB_ENV *, int (*)(DB_ENV *)));
00055 static int  __dbenv_set_server_noclnt
00056     __P((DB_ENV *, char *, long, long, u_int32_t));
00057 static int  __dbenv_set_shm_key __P((DB_ENV *, long));
00058 static int  __dbenv_set_tmp_dir __P((DB_ENV *, const char *));
00059 static int  __dbenv_set_verbose __P((DB_ENV *, u_int32_t, int));
00060 
00061 /*
00062  * CDB_db_env_create --
00063  *      DB_ENV constructor.
00064  */
00065 int
00066 CDB_db_env_create(dbenvpp, flags)
00067         DB_ENV **dbenvpp;
00068         u_int32_t flags;
00069 {
00070         DB_ENV *dbenv;
00071         int ret;
00072 
00073         /*
00074          * !!!
00075          * We can't call the flags-checking routines, we don't have an
00076          * environment yet.
00077          */
00078         if (flags != 0 && flags != DB_CLIENT)
00079                 return (EINVAL);
00080 
00081         if ((ret = CDB___os_calloc(NULL, 1, sizeof(*dbenv), &dbenv)) != 0)
00082                 return (ret);
00083 
00084 #ifdef HAVE_RPC
00085         if (LF_ISSET(DB_CLIENT))
00086                 F_SET(dbenv, DB_ENV_RPCCLIENT);
00087 #endif
00088         ret = CDB___dbenv_init(dbenv);
00089 
00090         if (ret != 0) {
00091                 CDB___os_free(dbenv, sizeof(*dbenv));
00092                 return (ret);
00093         }
00094 
00095         *dbenvpp = dbenv;
00096         return (0);
00097 }
00098 
00099 /*
00100  * CDB___dbenv_init --
00101  *      Initialize a DB_ENV structure.
00102  *
00103  * PUBLIC: int  CDB___dbenv_init __P((DB_ENV *));
00104  */
00105 int
00106 CDB___dbenv_init(dbenv)
00107         DB_ENV *dbenv;
00108 {
00109         /*
00110          * Set up methods that are the same in both normal and RPC
00111          */
00112         dbenv->err = __dbenv_err;
00113         dbenv->errx = __dbenv_errx;
00114         dbenv->set_errcall = __dbenv_set_errcall;
00115         dbenv->set_errfile = __dbenv_set_errfile;
00116         dbenv->set_errpfx = __dbenv_set_errpfx;
00117 
00118 #ifdef  HAVE_RPC
00119         if (F_ISSET(dbenv, DB_ENV_RPCCLIENT)) {
00120                 dbenv->close = __dbcl_env_close;
00121                 dbenv->open = __dbcl_env_open;
00122                 dbenv->remove = __dbcl_env_remove;
00123                 dbenv->set_data_dir = __dbcl_set_data_dir;
00124                 dbenv->set_feedback = __dbcl_env_set_feedback;
00125                 dbenv->set_paniccall = __dbcl_env_paniccall;
00126                 dbenv->set_recovery_init = __dbcl_set_recovery_init;
00127                 dbenv->set_server = __dbcl_envserver;
00128                 dbenv->set_shm_key = __dbcl_set_shm_key;
00129                 dbenv->set_tmp_dir = __dbcl_set_tmp_dir;
00130                 dbenv->set_verbose = __dbcl_set_verbose;
00131         } else {
00132 #endif
00133                 dbenv->close = CDB___dbenv_close;
00134                 dbenv->open = CDB___dbenv_open;
00135                 dbenv->remove = CDB___dbenv_remove;
00136                 dbenv->set_data_dir = __dbenv_set_data_dir;
00137                 dbenv->set_feedback = __dbenv_set_feedback;
00138                 dbenv->set_paniccall = __dbenv_set_paniccall;
00139                 dbenv->set_recovery_init = __dbenv_set_recovery_init;
00140                 dbenv->set_server = __dbenv_set_server_noclnt;
00141                 dbenv->set_shm_key = __dbenv_set_shm_key;
00142                 dbenv->set_tmp_dir = __dbenv_set_tmp_dir;
00143                 dbenv->set_verbose = __dbenv_set_verbose;
00144 #ifdef  HAVE_RPC
00145         }
00146 #endif
00147         dbenv->shm_key = INVALID_REGION_SEGID;
00148 
00149         CDB___log_dbenv_create(dbenv);          /* Subsystem specific. */
00150         CDB___lock_dbenv_create(dbenv);
00151         CDB___memp_dbenv_create(dbenv);
00152         CDB___txn_dbenv_create(dbenv);
00153 
00154         return (0);
00155 }
00156 
00157 /*
00158  * __dbenv_err --
00159  *      Error message, including the standard error string.
00160  */
00161 static void
00162 #ifdef __STDC__
00163 __dbenv_err(const DB_ENV *dbenv, int error, const char *fmt, ...)
00164 #else
00165 __dbenv_err(dbenv, error, fmt, va_alist)
00166         const DB_ENV *dbenv;
00167         int error;
00168         const char *fmt;
00169         va_dcl
00170 #endif
00171 {
00172         va_list ap;
00173 
00174 #ifdef __STDC__
00175         va_start(ap, fmt);
00176 #else
00177         va_start(ap);
00178 #endif
00179         CDB___db_real_err(dbenv, error, 1, 1, fmt, ap);
00180 
00181         va_end(ap);
00182 }
00183 
00184 /*
00185  * __dbenv_errx --
00186  *      Error message.
00187  */
00188 static void
00189 #ifdef __STDC__
00190 __dbenv_errx(const DB_ENV *dbenv, const char *fmt, ...)
00191 #else
00192 __dbenv_errx(dbenv, fmt, va_alist)
00193         const DB_ENV *dbenv;
00194         const char *fmt;
00195         va_dcl
00196 #endif
00197 {
00198         va_list ap;
00199 
00200 #ifdef __STDC__
00201         va_start(ap, fmt);
00202 #else
00203         va_start(ap);
00204 #endif
00205         CDB___db_real_err(dbenv, 0, 0, 1, fmt, ap);
00206 
00207         va_end(ap);
00208 }
00209 
00210 static int
00211 __dbenv_set_data_dir(dbenv, dir)
00212         DB_ENV *dbenv;
00213         const char *dir;
00214 {
00215         int ret;
00216 
00217 #define DATA_INIT_CNT   20                      /* Start with 20 data slots. */
00218         if (dbenv->db_data_dir == NULL) {
00219                 if ((ret = CDB___os_calloc(dbenv, DATA_INIT_CNT,
00220                     sizeof(char **), &dbenv->db_data_dir)) != 0)
00221                         return (ret);
00222                 dbenv->data_cnt = DATA_INIT_CNT;
00223         } else if (dbenv->data_next == dbenv->data_cnt - 1) {
00224                 dbenv->data_cnt *= 2;
00225                 if ((ret = CDB___os_realloc(dbenv,
00226                     dbenv->data_cnt * sizeof(char **),
00227                     NULL, &dbenv->db_data_dir)) != 0)
00228                         return (ret);
00229         }
00230         return (CDB___os_strdup(dbenv,
00231             dir, &dbenv->db_data_dir[dbenv->data_next++]));
00232 }
00233 
00234 static void
00235 __dbenv_set_errcall(dbenv, errcall)
00236         DB_ENV *dbenv;
00237         void (*errcall) __P((const char *, char *));
00238 {
00239         dbenv->db_errcall = errcall;
00240 }
00241 
00242 static void
00243 __dbenv_set_errfile(dbenv, errfile)
00244         DB_ENV *dbenv;
00245         FILE *errfile;
00246 {
00247         dbenv->db_errfile = errfile;
00248 }
00249 
00250 static void
00251 __dbenv_set_errpfx(dbenv, errpfx)
00252         DB_ENV *dbenv;
00253         const char *errpfx;
00254 {
00255         dbenv->db_errpfx = errpfx;
00256 }
00257 
00258 static int
00259 __dbenv_set_feedback(dbenv, feedback)
00260         DB_ENV *dbenv;
00261         void (*feedback) __P((DB_ENV *, int, int));
00262 {
00263         dbenv->db_feedback = feedback;
00264         return (0);
00265 }
00266 
00267 static int
00268 __dbenv_set_paniccall(dbenv, paniccall)
00269         DB_ENV *dbenv;
00270         void (*paniccall) __P((DB_ENV *, int));
00271 {
00272         dbenv->db_paniccall = paniccall;
00273         return (0);
00274 }
00275 
00276 static int
00277 __dbenv_set_recovery_init(dbenv, recovery_init)
00278         DB_ENV *dbenv;
00279         int (*recovery_init) __P((DB_ENV *));
00280 {
00281         ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_recovery_init");
00282 
00283         dbenv->db_recovery_init = recovery_init;
00284 
00285         return (0);
00286 }
00287 
00288 static int
00289 __dbenv_set_shm_key(dbenv, shm_key)
00290         DB_ENV *dbenv;
00291         long shm_key;                   /* !!!: really a key_t. */
00292 {
00293         ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_shm_key");
00294 
00295         dbenv->shm_key = shm_key;
00296         return (0);
00297 }
00298 
00299 static int
00300 __dbenv_set_tmp_dir(dbenv, dir)
00301         DB_ENV *dbenv;
00302         const char *dir;
00303 {
00304         if (dbenv->db_tmp_dir != NULL)
00305                 CDB___os_freestr(dbenv->db_tmp_dir);
00306         return (CDB___os_strdup(dbenv, dir, &dbenv->db_tmp_dir));
00307 }
00308 
00309 static int
00310 __dbenv_set_verbose(dbenv, which, onoff)
00311         DB_ENV *dbenv;
00312         u_int32_t which;
00313         int onoff;
00314 {
00315         switch (which) {
00316         case DB_VERB_CHKPOINT:
00317         case DB_VERB_DEADLOCK:
00318         case DB_VERB_RECOVERY:
00319         case DB_VERB_WAITSFOR:
00320                 if (onoff)
00321                         FLD_SET(dbenv->verbose, which);
00322                 else
00323                         FLD_CLR(dbenv->verbose, which);
00324                 break;
00325         default:
00326                 return (EINVAL);
00327         }
00328         return (0);
00329 }
00330 
00331 /*
00332  * CDB___db_mi_env --
00333  *      Method illegally called with public environment.
00334  *
00335  * PUBLIC: int CDB___db_mi_env __P((DB_ENV *, const char *));
00336  */
00337 int
00338 CDB___db_mi_env(dbenv, name)
00339         DB_ENV *dbenv;
00340         const char *name;
00341 {
00342         CDB___db_err(dbenv, "%s: method meaningless in shared environment", name);
00343         return (EINVAL);
00344 }
00345 
00346 /*
00347  * CDB___db_mi_open --
00348  *      Method illegally called after open.
00349  *
00350  * PUBLIC: int CDB___db_mi_open __P((DB_ENV *, const char *, int));
00351  */
00352 int
00353 CDB___db_mi_open(dbenv, name, after)
00354         DB_ENV *dbenv;
00355         const char *name;
00356         int after;
00357 {
00358         CDB___db_err(dbenv,
00359             "%s: method meaningless %s open", name, after ? "after" : "before");
00360         return (EINVAL);
00361 }
00362 
00363 /*
00364  * CDB___db_env_config --
00365  *      Method or function called without subsystem being configured.
00366  *
00367  * PUBLIC: int CDB___db_env_config __P((DB_ENV *, int));
00368  */
00369 int
00370 CDB___db_env_config(dbenv, subsystem)
00371         DB_ENV *dbenv;
00372         int subsystem;
00373 {
00374         const char *name;
00375 
00376         switch (subsystem) {
00377         case DB_INIT_LOCK:
00378                 name = "lock";
00379                 break;
00380         case DB_INIT_LOG:
00381                 name = "log";
00382                 break;
00383         case DB_INIT_MPOOL:
00384                 name = "mpool";
00385                 break;
00386         case DB_INIT_TXN:
00387                 name = "txn";
00388                 break;
00389         default:
00390                 name = "unknown";
00391                 break;
00392         }
00393         CDB___db_err(dbenv,
00394     "%s interface called with environment not configured for that subsystem",
00395             name);
00396         return (EINVAL);
00397 }
00398 
00399 static int
00400 __dbenv_set_server_noclnt(dbenv, host, tsec, ssec, flags)
00401         DB_ENV *dbenv;
00402         char *host;
00403         long tsec, ssec;
00404         u_int32_t flags;
00405 {
00406         COMPQUIET(host, NULL);
00407         COMPQUIET(tsec, 0);
00408         COMPQUIET(ssec, 0);
00409         COMPQUIET(flags, 0);
00410 
00411         CDB___db_err(dbenv, "set_server method meaningless in non-RPC enviroment");
00412         return(CDB___db_eopnotsup(dbenv));
00413 }

Generated on Sun Jun 8 10:56:37 2008 for GNUmifluz by  doxygen 1.5.5