Back to index

openldap  2.4.31
Defines | Functions | Variables
monitor.c File Reference
#include "portable.h"
#include <stdio.h>
#include <ac/string.h>
#include <ac/unistd.h>
#include <ac/stdlib.h>
#include <ac/errno.h>
#include <sys/stat.h>
#include "lutil.h"
#include "back-bdb.h"
#include "../back-monitor/back-monitor.h"
#include "config.h"

Go to the source code of this file.

Defines

#define bdb_monitor_initialize   BDB_SYMBOL(monitor_initialize)

Functions

static int bdb_monitor_update (Operation *op, SlapReply *rs, Entry *e, void *priv)
static int bdb_monitor_free (Entry *e, void **priv)
static int bdb_monitor_initialize (void)
int bdb_monitor_db_init (BackendDB *be)
int bdb_monitor_db_open (BackendDB *be)
int bdb_monitor_db_close (BackendDB *be)
int bdb_monitor_db_destroy (BackendDB *be)

Variables

static ObjectClassoc_olmBDBDatabase
static AttributeDescriptionad_olmBDBEntryCache
static AttributeDescriptionad_olmBDBDNCache
static AttributeDescriptionad_olmBDBIDLCache
static AttributeDescriptionad_olmDbDirectory
struct {
char * name
char * oid
s_oid []
struct {
char * desc
AttributeDescription ** ad
s_at []
struct {
char * desc
ObjectClass ** oc
s_oc []

Define Documentation

#define bdb_monitor_initialize   BDB_SYMBOL(monitor_initialize)

Definition at line 234 of file monitor.c.


Function Documentation

Definition at line 491 of file monitor.c.

{
       struct bdb_info             *bdb = (struct bdb_info *) be->be_private;

       if ( !BER_BVISNULL( &bdb->bi_monitor.bdm_ndn ) ) {
              BackendInfo          *mi = backend_info( "monitor" );
              monitor_extra_t             *mbe;

              if ( mi && &mi->bi_extra ) {
                     mbe = mi->bi_extra;
                     mbe->unregister_entry_callback( &bdb->bi_monitor.bdm_ndn,
                            (monitor_callback_t *)bdb->bi_monitor.bdm_cb,
                            NULL, 0, NULL );
              }

              memset( &bdb->bi_monitor, 0, sizeof( bdb->bi_monitor ) );
       }

       return 0;
}

Here is the call graph for this function:

Definition at line 516 of file monitor.c.

{
#ifdef BDB_MONITOR_IDX
       struct bdb_info             *bdb = (struct bdb_info *) be->be_private;

       /* TODO: free tree */
       ldap_pvt_thread_mutex_destroy( &bdb->bi_idx_mutex );
       avl_free( bdb->bi_idx, ch_free );
#endif /* BDB_MONITOR_IDX */

       return 0;
}

Here is the call graph for this function:

Definition at line 313 of file monitor.c.

{
       struct bdb_info             *bdb = (struct bdb_info *) be->be_private;

       if ( bdb_monitor_initialize() == LDAP_SUCCESS ) {
              /* monitoring in back-bdb is on by default */
              SLAP_DBFLAGS( be ) |= SLAP_DBFLAG_MONITORING;
       }

#ifdef BDB_MONITOR_IDX
       bdb->bi_idx = NULL;
       ldap_pvt_thread_mutex_init( &bdb->bi_idx_mutex );
#endif /* BDB_MONITOR_IDX */

       return 0;
}

Here is the call graph for this function:

Definition at line 334 of file monitor.c.

{
       struct bdb_info             *bdb = (struct bdb_info *) be->be_private;
       Attribute            *a, *next;
       monitor_callback_t   *cb = NULL;
       int                  rc = 0;
       BackendInfo          *mi;
       monitor_extra_t             *mbe;
       struct berval dummy = BER_BVC("");

       if ( !SLAP_DBMONITORING( be ) ) {
              return 0;
       }

       mi = backend_info( "monitor" );
       if ( !mi || !mi->bi_extra ) {
              SLAP_DBFLAGS( be ) ^= SLAP_DBFLAG_MONITORING;
              return 0;
       }
       mbe = mi->bi_extra;

       /* don't bother if monitor is not configured */
       if ( !mbe->is_configured() ) {
              static int warning = 0;

              if ( warning++ == 0 ) {
                     Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_monitor_db_open)
                            ": monitoring disabled; "
                            "configure monitor database to enable\n",
                            0, 0, 0 );
              }

              return 0;
       }

       /* alloc as many as required (plus 1 for objectClass) */
       a = attrs_alloc( 1 + 4 );
       if ( a == NULL ) {
              rc = 1;
              goto cleanup;
       }

       a->a_desc = slap_schema.si_ad_objectClass;
       attr_valadd( a, &oc_olmBDBDatabase->soc_cname, NULL, 1 );
       next = a->a_next;

       {
              struct berval bv = BER_BVC( "0" );

              next->a_desc = ad_olmBDBEntryCache;
              attr_valadd( next, &bv, NULL, 1 );
              next = next->a_next;

              next->a_desc = ad_olmBDBDNCache;
              attr_valadd( next, &bv, NULL, 1 );
              next = next->a_next;

              next->a_desc = ad_olmBDBIDLCache;
              attr_valadd( next, &bv, NULL, 1 );
              next = next->a_next;
       }

       {
              struct berval bv, nbv;
              ber_len_t     pathlen = 0, len = 0;
              char          path[ MAXPATHLEN ] = { '\0' };
              char          *fname = bdb->bi_dbenv_home,
                            *ptr;

              len = strlen( fname );
              if ( fname[ 0 ] != '/' ) {
                     /* get full path name */
                     getcwd( path, sizeof( path ) );
                     pathlen = strlen( path );

                     if ( fname[ 0 ] == '.' && fname[ 1 ] == '/' ) {
                            fname += 2;
                            len -= 2;
                     }
              }

              bv.bv_len = pathlen + STRLENOF( "/" ) + len;
              ptr = bv.bv_val = ch_malloc( bv.bv_len + STRLENOF( "/" ) + 1 );
              if ( pathlen ) {
                     ptr = lutil_strncopy( ptr, path, pathlen );
                     ptr[ 0 ] = '/';
                     ptr++;
              }
              ptr = lutil_strncopy( ptr, fname, len );
              if ( ptr[ -1 ] != '/' ) {
                     ptr[ 0 ] = '/';
                     ptr++;
              }
              ptr[ 0 ] = '\0';
              
              attr_normalize_one( ad_olmDbDirectory, &bv, &nbv, NULL );

              next->a_desc = ad_olmDbDirectory;
              next->a_vals = ch_calloc( sizeof( struct berval ), 2 );
              next->a_vals[ 0 ] = bv;
              next->a_numvals = 1;

              if ( BER_BVISNULL( &nbv ) ) {
                     next->a_nvals = next->a_vals;

              } else {
                     next->a_nvals = ch_calloc( sizeof( struct berval ), 2 );
                     next->a_nvals[ 0 ] = nbv;
              }

              next = next->a_next;
       }

       cb = ch_calloc( sizeof( monitor_callback_t ), 1 );
       cb->mc_update = bdb_monitor_update;
#if 0  /* uncomment if required */
       cb->mc_modify = bdb_monitor_modify;
#endif
       cb->mc_free = bdb_monitor_free;
       cb->mc_private = (void *)bdb;

       /* make sure the database is registered; then add monitor attributes */
       rc = mbe->register_database( be, &bdb->bi_monitor.bdm_ndn );
       if ( rc == 0 ) {
              rc = mbe->register_entry_attrs( &bdb->bi_monitor.bdm_ndn, a, cb,
                     &dummy, 0, &dummy );
       }

cleanup:;
       if ( rc != 0 ) {
              if ( cb != NULL ) {
                     ch_free( cb );
                     cb = NULL;
              }

              if ( a != NULL ) {
                     attrs_free( a );
                     a = NULL;
              }
       }

       /* store for cleanup */
       bdb->bi_monitor.bdm_cb = (void *)cb;

       /* we don't need to keep track of the attributes, because
        * bdb_monitor_free() takes care of everything */
       if ( a != NULL ) {
              attrs_free( a );
       }

       return rc;
}

Here is the call graph for this function:

static int bdb_monitor_free ( Entry e,
void **  priv 
) [static]

Definition at line 194 of file monitor.c.

{
       struct berval values[ 2 ];
       Modification  mod = { 0 };

       const char    *text;
       char          textbuf[ SLAP_TEXT_BUFLEN ];

       int           i, rc;

       /* NOTE: if slap_shutdown != 0, priv might have already been freed */
       *priv = NULL;

       /* Remove objectClass */
       mod.sm_op = LDAP_MOD_DELETE;
       mod.sm_desc = slap_schema.si_ad_objectClass;
       mod.sm_values = values;
       mod.sm_numvals = 1;
       values[ 0 ] = oc_olmBDBDatabase->soc_cname;
       BER_BVZERO( &values[ 1 ] );

       rc = modify_delete_values( e, &mod, 1, &text,
              textbuf, sizeof( textbuf ) );
       /* don't care too much about return code... */

       /* remove attrs */
       mod.sm_values = NULL;
       mod.sm_numvals = 0;
       for ( i = 0; s_at[ i ].desc != NULL; i++ ) {
              mod.sm_desc = *s_at[ i ].ad;
              rc = modify_delete_values( e, &mod, 1, &text,
                     textbuf, sizeof( textbuf ) );
              /* don't care too much about return code... */
       }
       
       return SLAP_CB_CONTINUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int bdb_monitor_initialize ( void  ) [static]

Definition at line 240 of file monitor.c.

{
       int           i, code;
       ConfigArgs c;
       char   *argv[ 3 ];

       static int    bdb_monitor_initialized = 0;

       /* set to 0 when successfully initialized; otherwise, remember failure */
       static int    bdb_monitor_initialized_failure = 1;

       if ( bdb_monitor_initialized++ ) {
              return bdb_monitor_initialized_failure;
       }

       if ( backend_info( "monitor" ) == NULL ) {
              return -1;
       }

       /* register schema here */

       argv[ 0 ] = "back-bdb/back-hdb monitor";
       c.argv = argv;
       c.argc = 3;
       c.fname = argv[0];

       for ( i = 0; s_oid[ i ].name; i++ ) {
              c.lineno = i;
              argv[ 1 ] = s_oid[ i ].name;
              argv[ 2 ] = s_oid[ i ].oid;

              if ( parse_oidm( &c, 0, NULL ) != 0 ) {
                     Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_monitor_initialize)
                            ": unable to add "
                            "objectIdentifier \"%s=%s\"\n",
                            s_oid[ i ].name, s_oid[ i ].oid, 0 );
                     return 2;
              }
       }

       for ( i = 0; s_at[ i ].desc != NULL; i++ ) {
              code = register_at( s_at[ i ].desc, s_at[ i ].ad, 1 );
              if ( code != LDAP_SUCCESS ) {
                     Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_monitor_initialize)
                            ": register_at failed for attributeType (%s)\n",
                            s_at[ i ].desc, 0, 0 );
                     return 3;

              } else {
                     (*s_at[ i ].ad)->ad_type->sat_flags |= SLAP_AT_HIDE;
              }
       }

       for ( i = 0; s_oc[ i ].desc != NULL; i++ ) {
              code = register_oc( s_oc[ i ].desc, s_oc[ i ].oc, 1 );
              if ( code != LDAP_SUCCESS ) {
                     Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_monitor_initialize)
                            ": register_oc failed for objectClass (%s)\n",
                            s_oc[ i ].desc, 0, 0 );
                     return 4;

              } else {
                     (*s_oc[ i ].oc)->soc_flags |= SLAP_OC_HIDE;
              }
       }

       return ( bdb_monitor_initialized_failure = LDAP_SUCCESS );
}

Here is the call graph for this function:

static int bdb_monitor_update ( Operation op,
SlapReply rs,
Entry e,
void priv 
) [static]

Definition at line 144 of file monitor.c.

{
       struct bdb_info             *bdb = (struct bdb_info *) priv;
       Attribute            *a;

       char                 buf[ BUFSIZ ];
       struct berval        bv;

       assert( ad_olmBDBEntryCache != NULL );

       a = attr_find( e->e_attrs, ad_olmBDBEntryCache );
       assert( a != NULL );
       bv.bv_val = buf;
       bv.bv_len = snprintf( buf, sizeof( buf ), "%lu", bdb->bi_cache.c_cursize );
       ber_bvreplace( &a->a_vals[ 0 ], &bv );

       a = attr_find( e->e_attrs, ad_olmBDBDNCache );
       assert( a != NULL );
       bv.bv_len = snprintf( buf, sizeof( buf ), "%lu", bdb->bi_cache.c_eiused );
       ber_bvreplace( &a->a_vals[ 0 ], &bv );

       a = attr_find( e->e_attrs, ad_olmBDBIDLCache );
       assert( a != NULL );
       bv.bv_len = snprintf( buf, sizeof( buf ), "%lu", bdb->bi_idl_cache_size );
       ber_bvreplace( &a->a_vals[ 0 ], &bv );
       
#ifdef BDB_MONITOR_IDX
       bdb_monitor_idx_entry_add( bdb, e );
#endif /* BDB_MONITOR_IDX */

       return SLAP_CB_CONTINUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 34 of file monitor.c.

Definition at line 34 of file monitor.c.

Definition at line 34 of file monitor.c.

Definition at line 34 of file monitor.c.

Definition at line 32 of file monitor.c.

struct { ... } s_at[] [static]
struct { ... } s_oc[] [static]
struct { ... } s_oid[] [static]