--- name: "DbLog" section: "3db" platform: "linux" package: "libdb2++-dev" version: "2.4.14-1" release: "Debian 2.1 (Slink)" platforms: ["linux"] url: "https://new.carta.tech/DbLog" --- # DbLog(3db) log management class ## NAME DbLog - log management class ## SYNOPSIS ``` #include static int DbLog::open(const char *dir, u_int32_t flags, int mode, DbEnv *dbenv, DbLog **regionp); int DbLog::close(); int DbLog::flush(const DbLsn *lsn); int DbLog::get(DbLsn *lsn, Dbt *data, u_int32_t flags); static int DbLog::compare(const DbLsn *lsn0, const DbLsn *lsn1); int DbLog::file(const DbLsn *lsn, char *namep, size_t len); int DbLog::put(DbLsn *lsn, const Dbt *data, u_int32_t flags); static int DbLog::unlink(const char *dir, int force, DbEnv *); int DbLog::archive(char **list[], u_int32_t flags, void *(*db_malloc)(size_t)); int DbLog::db_register(const Db *dbp, const char *name, DBTYPE type, u_int32_t *fidp); int DbLog::db_unregister(u_int32_t fid); int DbLog::stat(DB_LOG_STAT **spp, void *(*db_malloc)(size_t)); ``` ## DESCRIPTION The DB library is a family of classes that provides a modular programming interface to transactions and record-oriented file access. The library includes support for transactions, locking, logging and file page caching, as well as various indexed access methods. Many of the classes (e.g., the file page caching class) are useful independent of the other DB classes, although some classes are explicitly based on other classes (e.g., transactions and logging). For a general description of the DB package, see *db\_intro*(3). This manual page describes the specific details of the log class. This class provide a general-purpose logging facility sufficient for transaction management. Logs can be shared by multiple processes. The DB transaction log is represented by a directory containing a set of files. The log is a record-oriented, append-only file, with records identified and accessed via *DbLsn*'s (database log sequence numbers). DbLsn's are returned on each *DbLog::put* operation, and only those DbLsn's returned by *DbLog::put* can later be used to retrieve records from the log. *DbLog::open* The *DbLog::open* method copies a pointer, to the log identified by the **directory** *dir*, into the memory location referenced by *regionp*. If the *dbenv* argument to *DbLog::open* was initialized using *DbEnv::appinit*, *dir* is interpreted as described by *DbEnv*(3). Otherwise, if *dir* is not NULL, it is interpreted relative to the current working directory of the process. If *dir* is NULL, the following environment variables are checked in order: \`\`TMPDIR'', \`\`TEMP'', and \`\`TMP''. If one of them is set, log files are created relative to the directory it specifies. If none of them are set, the first possible one of the following directories is used: */var/tmp*, */usr/tmp*, */temp*, */tmp*, *C:/temp* and *C:/tmp*. All files associated with the log are created in this directory. This directory must already exist when DbLog::open is called. If the log already exists, the process must have permission to read and write the existing files. If the log does not already exist, it is optionally created and initialized. If the log region is being created and log files are already present, the log files are \`\`recovered'' and subsequent log writes are appended to the end of the log. The log is stored in one or more files in the specified directory. Each file is named using the format log.NNNNN where \`\`NNNNN'' is the sequence number of the file within the log. The *flags* and *mode* arguments specify how files will be opened and/or created when they don't already exist. The flags value is specified by **or**'ing together one or more of the following values: - DB\_CREATE Create any underlying files, as necessary. If the files do not already exist and the DB\_CREATE flag is not specified, the call will fail. - - DB\_THREAD Cause the DbLog handle returned by the *DbLog::open* method to be useable by multiple threads within a single address space, i.e., to be \`\`free-threaded''. All files created by the log subsystem are created with mode *mode* (as described in [*chmod*(2)](/chmod/2.md)) and modified by the process' umask value at the time of creation (see [*umask*(2)](/umask/2.md)). The group ownership of created files is based on the system and directory defaults, and is not further specified by DB. The logging subsystem is configured based on which set methods have been used. It is expected that applications will use a single DbEnv object as the argument to all of the subsystems in the DB package. The fields of the DbEnv object used by *DbLog::open* are described below. As references to the DbEnv object may be maintained by *DbLog::open*, it is necessary that the DbEnv object and memory it references be valid until the object is destroyed. Any of the DbEnv fields that are not explicitly set will default to appropriate values. The following fields in the DbEnv object may be initialized, using the appropriate set method, before calling *DbLog::open*: - - void \*(\*db\_errcall)(char \*db\_errpfx, char \*buffer); - FILE \*db\_errfile; - const char \*db\_errpfx; - class ostream \*db\_error\_stream; - int db\_verbose; The error fields of the DbEnv behave as described for *DbEnv*(3). - u\_int32\_t lg\_max; The maximum size of a single file in the log. Because DbLsn file offsets are unsigned 4-byte values, *lg\_max* may not be larger than the maximum unsigned 4-byte value. If *lg\_max* is 0, a default value is used. See the section "LOG FILE LIMITS" below, for further information. The *DbLog::open* method throws a *DbException*(3) or returns the value of *errno* on failure and 0 on success. *DbLog::close* The *DbLog::close* method closes the log associated with the DbLog object. In addition, if the *dir* argument to *DbLog::open* was NULL and *dbenv* was not initialized using *DbEnv::appinit*, all files created for this shared region will be removed, as if *DbLog::unlink* were called. When multiple threads are using the DbLog handle concurrently, only a single thread may call the *DbLog::close* method. The *DbLog::close* method throws a *DbException*(3) or returns the value of *errno* on failure and 0 on success. *DbLog::flush* The *DbLog::flush* method guarantees that all log records whose DbLsns are less than or equal to the *lsn* parameter have been written to disk. If *lsn* is NULL, all records in the log are flushed. The *DbLog::flush* method throws a *DbException*(3) or returns the value of *errno* on failure and 0 on success. *DbLog::get* The *DbLog::get* method implements a cursor inside of the log, retrieving records from the log according to the *lsn* and *flags* parameters. The data field of the *data* object is set to the record retrieved and the size field indicates the number of bytes in the record. See *Dbt*(3) for a description of other fields in the *data* object. **When multiple threads are using the returned DbLog handle concurrently,** **either the DB\_DBT\_MALLOC or DB\_DBT\_USERMEM flags must be specified for** **any Dbt used for data retrieval.** The *flags* parameter must be set to exactly one of the following values: - - DB\_CHECKPOINT The last record written with the DB\_CHECKPOINT flag specified to the *DbLog::put* method is returned in the *data* argument. The *lsn* argument is overwritten with the DbLsn of the record returned. If no record has been previously written with the DB\_CHECKPOINT flag specified, the first record in the log is returned. - If the log is empty the *DbLog::get* method will return DB\_NOTFOUND. - - DB\_FIRST The first record from any of the log files found in the log directory is returned in the *data* argument. The *lsn* argument is overwritten with the DbLsn of the record returned. - If the log is empty the *DbLog::get* method will return DB\_NOTFOUND. - - DB\_LAST The last record in the log is returned in the *data* argument. The *lsn* argument is overwritten with the DbLsn of the record returned. - If the log is empty, the *DbLog::get* method will return DB\_NOTFOUND. - - DB\_NEXT The current log position is advanced to the next record in the log and that record is returned in the *data* argument. The *lsn* argument is overwritten with the DbLsn of the record returned. - If the pointer has not been initialized via DB\_FIRST, DB\_LAST, DB\_SET, DB\_NEXT, or DB\_PREV, *DbLog::get* will return the first record in the log. If the last log record has already been returned or the log is empty, the *DbLog::get* method will return DB\_NOTFOUND. - If the log was opened with the DB\_THREAD flag set, calls to *DbLog::get* with the DB\_NEXT flag set will return EINVAL. - - DB\_PREV The current log position is moved to the previous record in the log and that record is returned in the *data* argument. The *lsn* argument is overwritten with the DbLsn of the record returned. - If the pointer has not been initialized via DB\_FIRST, DB\_LAST, DB\_SET, DB\_NEXT, or DB\_PREV, *DbLog::get* will return the last record in the log. If the first log record has already been returned or the log is empty, the *DbLog::get* method will return DB\_NOTFOUND. - If the log was opened with the DB\_THREAD flag set, calls to *DbLog::get* with the DB\_PREV flag set will return EINVAL. - - DB\_CURRENT Return the log record currently referenced by the log. - If the log pointer has not been initialized via DB\_FIRST, DB\_LAST, DB\_SET, DB\_NEXT, or DB\_PREV, or if the log was opened with the DB\_THREAD flag set, *DbLog::get* will return EINVAL. - DB\_SET Retrieve the record specified by the *lsn* argument. If the specified DbLsn is invalid (e.g., does not appear in the log) *DbLog::get* will return EINVAL. Otherwise, the *DbLog::get* method throws a *DbException*(3) or returns the value of *errno* on failure and 0 on success. *DbLog::compare* The *DbLog::compare* method allows the caller to compare two DbLsn's. *DbLog::compare* returns 0 if the two DbLsn's are equal, 1 if *lsn0* is greater than *lsn1*, and -1 if *lsn0* is less than *lsn1*. *DbLog::file* The *DbLog::file* method maps DbLsn's to file names. The *DbLog::file* method copies the name of the file containing the record named by *lsn* into the memory location referenced by *namep*. (This mapping of DbLsn to file is needed for database administration. For example, a transaction manager typically records the earliest DbLsn needed for restart, and the database administrator may want to archive log files to tape when they contain only DbLsn's before the earliest one needed for restart.) The *len* argument is the length of the *namep* buffer in bytes. If *namep* is too short to hold the file name, *DbLog::file* will return ENOMEM. Note, as described above, log file names are quite short, on the order of 10 characters. The *DbLog::file* method throws a *DbException*(3) or returns the value of *errno* on failure and 0 on success. *DbLog::put* The *DbLog::put* method appends records to the log. The DbLsn of the put record is returned in the *lsn* parameter. The *flags* parameter may be set to one of the following values: - - DB\_CHECKPOINT The log should write a checkpoint record, recording any information necessary to make the log structures recoverable after a crash. - - DB\_CURLSN The DB\_LSN of the next record to be put is returned in the *lsn* parameter. - - DB\_FLUSH The log is forced to disk after this record is written, guaranteeing that all records with DbLsns less than or equal to the one being put are on disk before this method returns (this function is most often used for a transaction commit, see *Db::Txn* in Db (3)). The caller is responsible for providing any necessary structure to *data*. (For example, in a write-ahead logging protocol, the application must understand what part of *data* is an operation code, what part is redo information, and what part is undo information. In addition, most transaction managers will store in *data* the DbLsn of the previous log record for the same transaction, to support chaining back through the transaction's log records during undo.) The *DbLog::put* method throws a *DbException*(3) or returns the value of *errno* on failure and 0 on success. *DbLog::unlink* The *DbLog::unlink* method destroys the log region identified by the directory *dir*, removing all files used to implement the log region. (The directory *dir* is not removed.) If there are processes that have called *DbLog::open* without calling *DbLog::close* (i.e., there are processes currently using the log region), *DbLog::unlink* will fail without further action, unless the force flag is set, in which case *DbLog::unlink* will attempt to remove the log region files regardless of any processes still using the log region. The result of attempting to forcibly destroy the region when a process has the region open is unspecified. Processes using a shared memory region maintain an open file descriptor for it. On UNIX systems, the region removal should succeed and processes that have already joined the region should continue to run in the region without change, however processes attempting to join the log region will either fail or attempt to create a new region. On other systems, e.g., WNT, where the [*unlink*(2)](/unlink/2.md) system call will fail if any process has an open file descriptor for the file, the region removal will fail. In the case of catastrophic or system failure, database recovery must be performed (see [*db\_recover*(1)](/db_recover/1.md) or the DB\_RECOVER and DB\_RECOVER\_FATAL flags to *DbEnv::appinit*(3)). Alternatively, if recovery is not required because no database state is maintained across failures, it is possible to clean up a log region by removing all of the files in the directory specified to the *DbLog::open* method, as log region files are never created in any directory other than the one specified to *DbLog::open*. Note, however, that this has the potential to remove files created by the other DB subsystems in this database environment. The *DbLog::unlink* method throws a *DbException*(3) or returns the value of *errno* on failure and 0 on success. *DbLog::archive* The *DbLog::archive* method creates a NULL-terminated array of log or database file names and copies a pointer to them into the user-specified memory location *list*. By default, *DbLog::archive* returns the names of all of the log files that are no longer in use (e.g., no longer involved in active transactions), and that may be archived for catastrophic recovery and then removed from the system. If there were no file names to return, *list* will be set to NULL. Arrays of log file names are created in allocated memory. If *db\_malloc* is non-NULL, it is called to allocate the memory, otherwise, the library function [*malloc*(3)](/malloc/3.md) is used. The function *db\_malloc* must match the calling conventions of the [*malloc*(3)](/malloc/3.md) library routine. Regardless, the caller is responsible for deallocating the returned memory. To deallocate the returned memory, free each returned memory pointer; pointers inside the memory do not need to be individually freed. The *flags* argument is specified by **or**'ing together one or more of the following values: - - DB\_ARCH\_ABS All pathnames are returned as absolute pathnames, instead of relative to the database home directory. - - DB\_ARCH\_DATA Return the database files that need to be archived in order to recover the database from catastrophic failure. If any of the database files have not been accessed during the lifetime of the current log files, *DbLog::archive* will not include them in this list. It is also possible that some of the files referenced in the log have since been deleted from the system. - - DB\_ARCH\_LOG Return all the log file names regardless of whether or not they are in use. The DB\_ARCH\_DATA and DB\_ARCH\_LOG flags are mutually exclusive. The *DbLog::archive* method throws a *DbException*(3) or returns the value of *errno* on failure and 0 on success. The *DbLog::archive* method is based on the C *log\_archive* function, which is the underlying function used by the [*db\_archive*(1)](/db_archive/1.md) utility. See the source code for the *db\_archive* utility for an example of using *log\_archive* in a UNIX environment. See the [*db\_archive*(1)](/db_archive/1.md) manual page for more information on database archival procedures. *DbLog::db\_register* The *DbLog::db\_register* method registers a file name with the log manager and copies a file identification number into the memory location referenced by *fidp*. This file identification number should be used in all subsequent log messages that refer to operations on this file. The log manager records all file name to file identification number mappings at each checkpoint so that a recovery process can identify the file to which a record in the log refers. The *DbLog::db\_register* method is called when an access method registers the open of a file. The *dbp* parameter should be a pointer to the Db object which is being returned by the access method. The *type* parameter should be one of the Db types specified in *Db::open* *(see*Db*(3)),* e.g., DB\_HASH. The *DbLog::db\_register* method throws a *DbException*(3) or returns the value of *errno* on failure and 0 on success. *DbLog::db\_unregister* The *DbLog::db\_unregister* method disassociates the file name to file identification number mapping for the file identification number specified by the *fid* parameter. The file identification number may then be reused. The *DbLog::db\_unregister* method throws a *DbException*(3) or returns the value of *errno* on failure and 0 on success. *DbLog::stat* The *DbLog::stat* function creates a statistical structure and copies a pointer to it into the user-specified memory location. Statistical structures are created in allocated memory. If *db\_malloc* is non-NULL, it is called to allocate the memory, otherwise, the library function [*malloc*(3)](/malloc/3.md) is used. The function *db\_malloc* must match the calling conventions of the [*malloc*(3)](/malloc/3.md) library routine. Regardless, the caller is responsible for deallocating the returned memory. To deallocate the returned memory, free each returned memory pointer; pointers inside the memory do not need to be individually freed. The log statistics are stored in a structure of type DB\_LOG\_STAT (typedef'd in \). The following DB\_LOG\_STAT fields will be filled in: - u\_int32\_t st\_magic; The magic number that identifies a file as a log file.\ - u\_int32\_t st\_version; The version of the log file type.\ - u\_int32\_t st\_refcnt; The number of references to the region.\ - u\_int32\_t st\_regsize; The size of the region.\ - u\_int32\_t st\_mode; The mode of any created log files.\ - u\_int32\_t st\_lg\_max; The maximum size of any individual file comprising the log.\ - u\_int32\_t st\_written; The total number of bytes written to this log.\ - u\_int32\_t st\_written\_chkpt; The number of bytes written since the last checkpoint.\ - u\_int32\_t st\_region\_wait; The number of times that a process was able to obtain the region lock without waiting.\ - u\_int32\_t st\_region\_nowait; The number of times that a process was forced to wait before obtaining the region lock. ## LOG FILE LIMITS Log file sizes impose a time limit on the length of time a database may be accessed under transaction protection, before it needs to be dumped and reloaded (see *db\_dump(3)* and *db\_load(3)).* Unfortunately, the limits are potentially difficult to calculate. The log file name consists of "log." followed by 5 digits, resulting in a maximum of 99,999 log files. Consider an application performing 600 transactions per second, for 15 hours a day, logged into 10Mb log files, where each transaction is logging approximately 100 bytes of data. The calculation: ``` (10 * 2^20 * 99999) / (600 * 60 * 60 * 15 * 100) = 323.63 ``` indicates that the system will run out of log file space in roughly 324 days. If we increase the maximum size of the files from 10Mb to 100Mb, the same calculation indicates that the application will run out of log file space in roughly 9 years. There is no way to reset the log file name space in Berkeley DB. If your application is reaching the end of its log file name space, you should: - 1\. Archive your databases as if to prepare for catastrophic failure (see [*db\_archive*(1)](/db_archive/1.md) for more information). - 2\. Dump and re-load **all** your databases (see [*db\_dump*(1)](/db_dump/1.md) and [*db\_load*(1)](/db_load/1.md) for more information). - 3\. Remove all of the log files from the database environment (see [*db\_archive*(1)](/db_archive/1.md) for more information). - 4\. Restart your applications. ## ENVIRONMENT VARIABLES The following environment variables affect the execution of *db\_log*: - DB\_HOME If the *dbenv* argument to *DbLog::open* was initialized using *db\_appinit*, the environment variable DB\_HOME may be used as the path of the database home for the interpretation of the *dir* argument to *DbLog::open*, as described in *db\_appinit*(3). Specifically, *DbLog::open* is affected by the configuration string value of DB\_LOG\_DIR. - TMPDIR If the *dbenv* argument to *DbLog::open* was NULL or not initialized using *db\_appinit*, the environment variable TMPDIR may be used as the directory in which to create the log, as described in the *DbLog::open* section above. ## ERRORS Methods marked as returning *errno* will, by default, throw an exception that encapsulates the error information. The default error behavior can be changed, see *DbException*(3). The *DbLog::open* method may fail and throw a *DbException*(3) or return *errno* for any of the errors specified for the following DB and library functions: DbLog::close(3), DbLog::unlink(3), [atoi(3)](/atoi/3.md), [close(2)](/close/2.md), db\_version(3), [fcntl(2)](/fcntl/2.md), [fflush(3)](/fflush/3.md), [lseek(2)](/lseek/2.md), [malloc(3)](/malloc/3.md), [memcpy(3)](/memcpy/3.md), [memset(3)](/memset/3.md), [mmap(2)](/mmap/2.md), [munmap(2)](/munmap/2.md), [open(2)](/open/2.md), [opendir(3)](/opendir/3.md), [read(2)](/read/2.md), [readdir(3)](/readdir/3.md), [realloc(3)](/realloc/3.md), [sigfillset(3)](/sigfillset/3.md), [sigprocmask(2)](/sigprocmask/2.md), [stat(2)](/stat/2.md), [strchr(3)](/strchr/3.md), [strcpy(3)](/strcpy/3.md), [strdup(3)](/strdup/3.md), [strerror(3)](/strerror/3.md), [strlen(3)](/strlen/3.md), [strncmp(3)](/strncmp/3.md), [unlink(2)](/unlink/2.md), and [write(2)](/write/2.md). In addition, the *DbLog::open* method may fail and throw a *DbException*(3) or return *errno* for the following conditions: - \[EAGAIN\] The shared memory region was locked and (repeatedly) unavailable. - \[EINVAL\] An invalid flag value or parameter was specified. The DB\_THREAD flag was specified and spinlocks are not implemented for this architecture. The specified file size was too large. The *DbLog::close* method may fail and throw a *DbException*(3) or return *errno* for any of the errors specified for the following DB and library functions: [close(2)](/close/2.md), [fcntl(2)](/fcntl/2.md), [fflush(3)](/fflush/3.md), [munmap(2)](/munmap/2.md), and [strerror(3)](/strerror/3.md). The *DbLog::flush* method may fail and throw a *DbException*(3) or return *errno* for any of the errors specified for the following DB and library functions: [close(2)](/close/2.md), [fcntl(2)](/fcntl/2.md), [fflush(3)](/fflush/3.md), [fsync(2)](/fsync/2.md), [lseek(2)](/lseek/2.md), [malloc(3)](/malloc/3.md), [memcpy(3)](/memcpy/3.md), [memset(3)](/memset/3.md), [open(2)](/open/2.md), [sigfillset(3)](/sigfillset/3.md), [sigprocmask(2)](/sigprocmask/2.md), [stat(2)](/stat/2.md), [strcpy(3)](/strcpy/3.md), [strdup(3)](/strdup/3.md), [strerror(3)](/strerror/3.md), [strlen(3)](/strlen/3.md), [unlink(2)](/unlink/2.md), and [write(2)](/write/2.md). In addition, the *DbLog::flush* method may fail and throw a *DbException*(3) or return *errno* for the following conditions: - \[EINVAL\] An invalid flag value or parameter was specified. The *DbLog::get* method may fail and throw a *DbException*(3) or return *errno* for any of the errors specified for the following DB and library functions: [atoi(3)](/atoi/3.md), [close(2)](/close/2.md), [fcntl(2)](/fcntl/2.md), [fflush(3)](/fflush/3.md), [lseek(2)](/lseek/2.md), [malloc(3)](/malloc/3.md), [memcpy(3)](/memcpy/3.md), [memset(3)](/memset/3.md), [open(2)](/open/2.md), [opendir(3)](/opendir/3.md), [read(2)](/read/2.md), [readdir(3)](/readdir/3.md), [realloc(3)](/realloc/3.md), [sigfillset(3)](/sigfillset/3.md), [sigprocmask(2)](/sigprocmask/2.md), [stat(2)](/stat/2.md), [strchr(3)](/strchr/3.md), [strcpy(3)](/strcpy/3.md), [strdup(3)](/strdup/3.md), [strerror(3)](/strerror/3.md), [strlen(3)](/strlen/3.md), [strncmp(3)](/strncmp/3.md), and [unlink(2)](/unlink/2.md). In addition, the *DbLog::get* method may fail and throw a *DbException*(3) or return *errno* for the following conditions: - \[EINVAL\] An invalid flag value or parameter was specified. The DB\_FIRST flag was specified and no log files were found. The *DbLog::file* method may fail and throw a *DbException*(3) or return *errno* for any of the errors specified for the following DB and library functions: [close(2)](/close/2.md), [fcntl(2)](/fcntl/2.md), [fflush(3)](/fflush/3.md), [malloc(3)](/malloc/3.md), [memcpy(3)](/memcpy/3.md), [memset(3)](/memset/3.md), [open(2)](/open/2.md), [sigfillset(3)](/sigfillset/3.md), [sigprocmask(2)](/sigprocmask/2.md), [stat(2)](/stat/2.md), [strcpy(3)](/strcpy/3.md), [strdup(3)](/strdup/3.md), [strerror(3)](/strerror/3.md), [strlen(3)](/strlen/3.md), and [unlink(2)](/unlink/2.md). In addition, the *DbLog::file* method may fail and throw a *DbException*(3) or return *errno* for the following conditions: - \[ENOMEM\] The supplied buffer was too small to hold the log file name. The *DbLog::put* method may fail and throw a *DbException*(3) or return *errno* for any of the errors specified for the following DB and library functions: [close(2)](/close/2.md), [fcntl(2)](/fcntl/2.md), [fflush(3)](/fflush/3.md), [fsync(2)](/fsync/2.md), [lseek(2)](/lseek/2.md), [malloc(3)](/malloc/3.md), [memcpy(3)](/memcpy/3.md), [memset(3)](/memset/3.md), [open(2)](/open/2.md), [sigfillset(3)](/sigfillset/3.md), [sigprocmask(2)](/sigprocmask/2.md), [stat(2)](/stat/2.md), [strcpy(3)](/strcpy/3.md), [strdup(3)](/strdup/3.md), [strerror(3)](/strerror/3.md), [strlen(3)](/strlen/3.md), [time(3)](/time/3.md), [unlink(2)](/unlink/2.md), and [write(2)](/write/2.md). In addition, the *DbLog::put* method may fail and throw a *DbException*(3) or return *errno* for the following conditions: - \[EINVAL\] An invalid flag value or parameter was specified. The record to be logged is larger than the maximum log record. The *DbLog::unlink* method may fail and throw a *DbException*(3) or return *errno* for any of the errors specified for the following DB and library functions: [close(2)](/close/2.md), [fcntl(2)](/fcntl/2.md), [fflush(3)](/fflush/3.md), [malloc(3)](/malloc/3.md), [memcpy(3)](/memcpy/3.md), [memset(3)](/memset/3.md), [mmap(2)](/mmap/2.md), [munmap(2)](/munmap/2.md), [open(2)](/open/2.md), [sigfillset(3)](/sigfillset/3.md), [sigprocmask(2)](/sigprocmask/2.md), [stat(2)](/stat/2.md), [strcpy(3)](/strcpy/3.md), [strdup(3)](/strdup/3.md), [strerror(3)](/strerror/3.md), [strlen(3)](/strlen/3.md), and [unlink(2)](/unlink/2.md). In addition, the *DbLog::unlink* method may fail and throw a *DbException*(3) or return *errno* for the following conditions: - \[EBUSY\] The shared memory region was in use and the force flag was not set. The *DbLog::archive* method may fail and throw a *DbException*(3) or return *errno* for any of the errors specified for the following DB and library functions: DbLog::compare(3), DbLog::get(3), [close(2)](/close/2.md), [fcntl(2)](/fcntl/2.md), [fflush(3)](/fflush/3.md), [getcwd(3)](/getcwd/3.md), [malloc(3)](/malloc/3.md), [memcpy(3)](/memcpy/3.md), [memset(3)](/memset/3.md), [open(2)](/open/2.md), [qsort(3)](/qsort/3.md), [realloc(3)](/realloc/3.md), [sigfillset(3)](/sigfillset/3.md), [sigprocmask(2)](/sigprocmask/2.md), [stat(2)](/stat/2.md), [strchr(3)](/strchr/3.md), [strcmp(3)](/strcmp/3.md), [strcpy(3)](/strcpy/3.md), [strdup(3)](/strdup/3.md), [strerror(3)](/strerror/3.md), [strlen(3)](/strlen/3.md), and [unlink(2)](/unlink/2.md). In addition, the *DbLog::archive* method may fail and throw a *DbException*(3) or return *errno* for the following conditions: - \[EINVAL\] An invalid flag value or parameter was specified. The log was corrupted. The *DbLog::db\_register* method may fail and throw a *DbException*(3) or return *errno* for any of the errors specified for the following DB and library functions: [close(2)](/close/2.md), [fcntl(2)](/fcntl/2.md), [fflush(3)](/fflush/3.md), [fsync(2)](/fsync/2.md), [lseek(2)](/lseek/2.md), [malloc(3)](/malloc/3.md), [memcmp(3)](/memcmp/3.md), [memcpy(3)](/memcpy/3.md), [memset(3)](/memset/3.md), [open(2)](/open/2.md), [realloc(3)](/realloc/3.md), [sigfillset(3)](/sigfillset/3.md), [sigprocmask(2)](/sigprocmask/2.md), [stat(2)](/stat/2.md), [strcpy(3)](/strcpy/3.md), [strdup(3)](/strdup/3.md), [strerror(3)](/strerror/3.md), [strlen(3)](/strlen/3.md), [time(3)](/time/3.md), [unlink(2)](/unlink/2.md), and [write(2)](/write/2.md). In addition, the *DbLog::db\_register* method may fail and throw a *DbException*(3) or return *errno* for the following conditions: - \[EINVAL\] An invalid flag value or parameter was specified. The *DbLog::db\_unregister* method may fail and throw a *DbException*(3) or return *errno* for any of the errors specified for the following DB and library functions: [close(2)](/close/2.md), [fcntl(2)](/fcntl/2.md), [fflush(3)](/fflush/3.md), [fsync(2)](/fsync/2.md), [lseek(2)](/lseek/2.md), [malloc(3)](/malloc/3.md), [memcpy(3)](/memcpy/3.md), [memset(3)](/memset/3.md), [open(2)](/open/2.md), [sigfillset(3)](/sigfillset/3.md), [sigprocmask(2)](/sigprocmask/2.md), [stat(2)](/stat/2.md), [strcpy(3)](/strcpy/3.md), [strdup(3)](/strdup/3.md), [strerror(3)](/strerror/3.md), [strlen(3)](/strlen/3.md), [time(3)](/time/3.md), [unlink(2)](/unlink/2.md), and [write(2)](/write/2.md). In addition, the *DbLog::db\_unregister* method may fail and throw a *DbException*(3) or return *errno* for the following conditions: - \[EINVAL\] An invalid flag value or parameter was specified. ## BUGS The log files are not machine architecture independent. Specifically, their metadata are not stored in a fixed byte order. ## SEE ALSO [*db\_archive*(1)](/db_archive/1.md), [*db\_checkpoint*(1)](/db_checkpoint/1.md), [*db\_deadlock*(1)](/db_deadlock/1.md), [*db\_dump*(1)](/db_dump/1.md), [*db\_load*(1)](/db_load/1.md), [*db\_recover*(1)](/db_recover/1.md), [*db\_stat*(1)](/db_stat/1.md), *db\_intro*(3), *db\_internal*(3), *db\_thread*(3), *Db*(3), *Dbc*(3), *DbEnv*(3), *DbException*(3), *DbInfo*(3), *DbLock*(3), *DbLockTab*(3), *DbLog*(3), *DbLsn*(3), *DbMpool*(3), *DbMpoolFile*(3), *Dbt*(3), *DbTxn*(3), *DbTxnMgr*(3)