static int polrun_read_triggers(config_file_t config, const char *policy_name, policy_run_config_t *conf, char *msg_out) { int rc; unsigned int blk_index; char block_name[1024]; /* get TRIGGER blocks */ snprintf(block_name, sizeof(block_name), "%s" TRIGGER_SUFFIX, policy_name); for (blk_index = 0; blk_index < rh_config_GetNbBlocks(config); blk_index++) { char *curr_bname; config_item_t curr_item = rh_config_GetBlockByIndex(config, blk_index); critical_err_check(curr_item, "root"); if (rh_config_ItemType(curr_item) != CONFIG_ITEM_BLOCK) continue; curr_bname = rh_config_GetBlockName(curr_item); critical_err_check(curr_bname, "root"); if (!strcasecmp(curr_bname, block_name)) { conf->trigger_count++; /* realloc behaves as malloc when trigger_list is NULL */ conf->trigger_list = (trigger_item_t *) realloc(conf->trigger_list, conf-> trigger_count * sizeof (trigger_item_t)); if (conf->trigger_list == NULL) return ENOMEM; /* analyze trigger block */ rc = parse_trigger_block(curr_item, curr_bname, &conf->trigger_list[conf->trigger_count - 1], msg_out); if (rc) return rc; } } return 0; }
int Read_ResourceMon_Config( config_file_t config, void *module_config, char *msg_out, int for_reload ) { int rc; int intval; resource_monitor_config_t *conf = ( resource_monitor_config_t * ) module_config; unsigned int blc_index; static const char *purge_allowed[] = { "nb_threads_purge", "post_purge_df_latency", "purge_queue_size", "db_result_size_max", #ifdef ATTR_INDEX_status "check_purge_status_on_startup", #endif "recheck_ignored_classes", #ifdef _TMP_FS_MGR "purge_command", #endif NULL }; /* get PURGE_PARAM block */ config_item_t param_block = rh_config_FindItemByName( config, PURGE_PARAM_BLOCK ); if ( param_block != NULL ) { /* no error, because no parameter is mandatory */ /* check this is a block... */ if ( rh_config_ItemType( param_block ) != CONFIG_ITEM_BLOCK ) { strcpy( msg_out, "A block is expected for '" PURGE_PARAM_BLOCK "' item" ); return EINVAL; } /* parse parameters */ rc = GetIntParam( param_block, PURGE_PARAM_BLOCK, "nb_threads_purge", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->nb_threads_purge, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetDurationParam( param_block, PURGE_PARAM_BLOCK, "post_purge_df_latency", INT_PARAM_POSITIVE, /* 0 is authorized: no delay */ &intval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc != ENOENT ) conf->post_purge_df_latency = intval; rc = GetIntParam( param_block, PURGE_PARAM_BLOCK, "purge_queue_size", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->purge_queue_size, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetIntParam( param_block, PURGE_PARAM_BLOCK, "db_result_size_max", INT_PARAM_POSITIVE, ( int * ) &conf->db_request_limit, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; #ifdef ATTR_INDEX_status rc = GetBoolParam( param_block, PURGE_PARAM_BLOCK, "check_purge_status_on_startup", 0, &intval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc != ENOENT ) conf->check_purge_status_on_startup = intval; #endif rc = GetBoolParam( param_block, PURGE_PARAM_BLOCK, "recheck_ignored_classes", 0, &intval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc != ENOENT ) conf->recheck_ignored_classes = intval; rc = GetBoolParam( param_block, PURGE_PARAM_BLOCK, "simulation_mode", 0, &intval, NULL, NULL, msg_out ); if ( rc == 0 ) { DisplayLog( LVL_CRIT, RESMONCFG_TAG, "WARNING: 'simulation_mode' parameter is deprecated. Use '--dry-run' option instead."); } #ifdef _TMP_FS_MGR rc = GetStringParam(param_block, PURGE_PARAM_BLOCK, "purge_command", STR_PARAM_ABSOLUTE_PATH, /* can contain wildcards: {path}, {fid}, {fsname} */ conf->purge_command, RBH_PATH_MAX, NULL, NULL, msg_out); if ((rc != 0) && (rc != ENOENT)) return rc; #endif CheckUnknownParameters( param_block, PURGE_PARAM_BLOCK, purge_allowed ); } /* end of purge parameters */ /* get PURGE_TRIGGER blocks */ for ( blc_index = 0; blc_index < rh_config_GetNbBlocks( config ); blc_index++ ) { char *block_name; config_item_t curr_item = rh_config_GetBlockByIndex( config, blc_index ); critical_err_check( curr_item, "root" ); if ( rh_config_ItemType( curr_item ) != CONFIG_ITEM_BLOCK ) continue; block_name = rh_config_GetBlockName( curr_item ); critical_err_check( block_name, "root" ); if ( !strcasecmp( block_name, TRIGGER_BLOCK ) ) { if ( conf->trigger_count == 0 ) conf->trigger_list = ( trigger_item_t * ) malloc( sizeof( trigger_item_t ) ); else conf->trigger_list = ( trigger_item_t * ) realloc( conf->trigger_list, ( conf->trigger_count + 1 ) * sizeof( trigger_item_t ) ); conf->trigger_count++; /* analyze trigger block */ rc = parse_trigger_block( curr_item, block_name, &conf->trigger_list[conf->trigger_count - 1], msg_out ); if ( rc ) return rc; } } return 0; }
int Read_EntryProc_Config( config_file_t config, void *module_config, char *msg_out, int for_reload ) { int rc, blc_index, i; int tmpval; entry_proc_config_t *conf = ( entry_proc_config_t * ) module_config; char pipeline_names[PIPELINE_STAGE_COUNT][256]; char *entry_proc_allowed[PIPELINE_STAGE_COUNT + 5]; entry_proc_allowed[0] = "nb_threads"; entry_proc_allowed[1] = "max_pending_operations"; entry_proc_allowed[2] = "match_classes"; entry_proc_allowed[3] = ALERT_BLOCK; entry_proc_allowed[PIPELINE_STAGE_COUNT + 4] = NULL; /* PIPELINE_STAGE_COUNT+4 = last slot */ /* get EntryProcessor block */ config_item_t entryproc_block = rh_config_FindItemByName( config, ENTRYPROC_CONFIG_BLOCK ); if ( entryproc_block == NULL ) { strcpy( msg_out, "Missing configuration block '" ENTRYPROC_CONFIG_BLOCK "'" ); /* No error because no parameter is mandatory */ return 0; } if ( rh_config_ItemType( entryproc_block ) != CONFIG_ITEM_BLOCK ) { strcpy( msg_out, "A block is expected for '" ENTRYPROC_CONFIG_BLOCK "' item" ); return EINVAL; } /* retrieve parameters */ rc = GetIntParam( entryproc_block, ENTRYPROC_CONFIG_BLOCK, "nb_threads", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->nb_thread, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetIntParam( entryproc_block, ENTRYPROC_CONFIG_BLOCK, "max_pending_operations", INT_PARAM_POSITIVE, ( int * ) &conf->max_pending_operations, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetBoolParam( entryproc_block, ENTRYPROC_CONFIG_BLOCK, "match_classes", 0, &conf->match_classes, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; /* look for '<stage>_thread_max' parameters */ for ( i = 0; i < PIPELINE_STAGE_COUNT; i++ ) { char varname[256]; snprintf( varname, 256, "%s_threads_max", entry_proc_pipeline[i].stage_name ); strncpy( pipeline_names[i], varname, 256 ); entry_proc_allowed[i + 4] = pipeline_names[i]; rc = GetIntParam( entryproc_block, ENTRYPROC_CONFIG_BLOCK, varname, INT_PARAM_POSITIVE, &tmpval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( ( rc != ENOENT ) && ( tmpval > 0 ) ) /* 0: keep default */ { if ( entry_proc_pipeline[i].stage_flags & STAGE_FLAG_MAX_THREADS ) entry_proc_pipeline[i].max_thread_count = MIN2( entry_proc_pipeline[i].max_thread_count, tmpval ); else if ( entry_proc_pipeline[i].stage_flags & STAGE_FLAG_PARALLEL ) { /* the stqge is no more parallel, it has a limited number of threads */ entry_proc_pipeline[i].stage_flags &= ~STAGE_FLAG_PARALLEL; entry_proc_pipeline[i].stage_flags |= STAGE_FLAG_MAX_THREADS; entry_proc_pipeline[i].max_thread_count = tmpval; } else if ( ( entry_proc_pipeline[i].stage_flags & STAGE_FLAG_SEQUENTIAL ) && ( tmpval != 1 ) ) { sprintf( msg_out, "%s is sequential. Cannot use %u threads at this stage.", entry_proc_pipeline[i].stage_name, tmpval ); return EINVAL; } } } /* Find and parse "Alert" blocks */ for ( blc_index = 0; blc_index < rh_config_GetNbItems( entryproc_block ); blc_index++ ) { char *block_name; config_item_t curr_item = rh_config_GetItemByIndex( entryproc_block, blc_index ); critical_err_check( curr_item, ENTRYPROC_CONFIG_BLOCK ); if ( rh_config_ItemType( curr_item ) != CONFIG_ITEM_BLOCK ) continue; block_name = rh_config_GetBlockName( curr_item ); critical_err_check( curr_item, ENTRYPROC_CONFIG_BLOCK ); if ( !strcasecmp( block_name, ALERT_BLOCK ) ) { char * alert_title = NULL; if ( conf->alert_count == 0 ) conf->alert_list = ( alert_item_t * ) malloc( sizeof( alert_item_t ) ); else conf->alert_list = ( alert_item_t * ) realloc( conf->alert_list, ( conf->alert_count + 1 ) * sizeof( alert_item_t ) ); conf->alert_count++; alert_title = rh_config_GetBlockId( curr_item ); if ( alert_title != NULL ) strncpy( conf->alert_list[conf->alert_count - 1].title, alert_title, ALERT_TITLE_MAX ); else conf->alert_list[conf->alert_count - 1].title[0] = '\0'; /* analyze boolean expression */ rc = GetBoolExpr( curr_item, block_name, &conf->alert_list[conf->alert_count - 1].boolexpr, &conf->alert_list[conf->alert_count - 1].attr_mask, msg_out ); if ( rc ) return rc; conf->alert_attr_mask |= conf->alert_list[conf->alert_count - 1].attr_mask; } } /* Loop on subblocks */ CheckUnknownParameters( entryproc_block, ENTRYPROC_CONFIG_BLOCK, ( const char ** ) entry_proc_allowed ); return 0; }
int FSScan_ReadConfig( config_file_t config, void *module_config, char *msg_out, int for_reload ) { int rc, blc_index; fs_scan_config_t *conf = ( fs_scan_config_t * ) module_config; int scan_intl_set = FALSE; int scan_intl = 0; static const char * fsscan_allowed[] = { "scan_interval", "min_scan_interval", "max_scan_interval", "scan_retry_delay", "nb_threads_scan", "scan_op_timeout", "exit_on_timeout", "spooler_check_interval", "nb_prealloc_tasks", "completion_command", IGNORE_BLOCK, NULL }; /* get FS Scan block */ config_item_t fsscan_block = rh_config_FindItemByName( config, FSSCAN_CONFIG_BLOCK ); if ( fsscan_block == NULL ) { strcpy( msg_out, "Missing configuration block '" FSSCAN_CONFIG_BLOCK "'" ); /* No error because no parameter is mandatory */ return 0; } if ( rh_config_ItemType( fsscan_block ) != CONFIG_ITEM_BLOCK ) { strcpy( msg_out, "A block is expected for '" FSSCAN_CONFIG_BLOCK "' item" ); return EINVAL; } /* retrieve parameters */ rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "min_scan_interval", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->min_scan_interval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc == 0 ) scan_intl_set = TRUE; rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "max_scan_interval", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->max_scan_interval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc == 0 ) scan_intl_set = TRUE; rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "scan_interval", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, &scan_intl, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; else if ( rc == 0 ) { if (scan_intl_set) { strcpy( msg_out, "scan_interval parameter cannot be used with min/max_scan_interval" ); return EINVAL; } conf->min_scan_interval = scan_intl; conf->max_scan_interval = scan_intl; } rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "scan_retry_delay", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->scan_retry_delay, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetIntParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "nb_threads_scan", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->nb_threads_scan, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "scan_op_timeout", INT_PARAM_POSITIVE, /* 0 is authorized => no timeout */ ( int * ) &conf->scan_op_timeout, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetBoolParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "exit_on_timeout", 0, (int*)&conf->exit_on_timeout, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "spooler_check_interval", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->spooler_check_interval, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetDurationParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "nb_prealloc_tasks", INT_PARAM_POSITIVE | INT_PARAM_NOT_NULL, ( int * ) &conf->nb_prealloc_tasks, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; rc = GetStringParam( fsscan_block, FSSCAN_CONFIG_BLOCK, "completion_command", STR_PARAM_ABSOLUTE_PATH, /* can contain wildcards: {cfg} or {fspath} */ conf->completion_command, RBH_PATH_MAX, NULL, NULL, msg_out ); if ( ( rc != 0 ) && ( rc != ENOENT ) ) return rc; /* Find and parse "ignore" blocks */ for ( blc_index = 0; blc_index < rh_config_GetNbItems( fsscan_block ); blc_index++ ) { char *block_name; config_item_t curr_item = rh_config_GetItemByIndex( fsscan_block, blc_index ); critical_err_check( curr_item, FSSCAN_CONFIG_BLOCK ); if ( rh_config_ItemType( curr_item ) != CONFIG_ITEM_BLOCK ) continue; block_name = rh_config_GetBlockName( curr_item ); critical_err_check( curr_item, FSSCAN_CONFIG_BLOCK ); if ( !strcasecmp( block_name, IGNORE_BLOCK ) ) { if ( conf->ignore_count == 0 ) conf->ignore_list = ( whitelist_item_t * ) malloc( sizeof( whitelist_item_t ) ); else conf->ignore_list = ( whitelist_item_t * ) realloc( conf->ignore_list, ( conf->ignore_count + 1 ) * sizeof( whitelist_item_t ) ); conf->ignore_count++; /* analyze boolean expression */ rc = GetBoolExpr( curr_item, block_name, &conf->ignore_list[conf->ignore_count - 1].bool_expr, &conf->ignore_list[conf->ignore_count - 1].attr_mask, msg_out ); if ( rc ) return rc; } } /* Loop on subblocks */ CheckUnknownParameters( fsscan_block, FSSCAN_CONFIG_BLOCK, fsscan_allowed ); return 0; }