int setComponentLogLevel(const snmp_adm_type_union * param, void *opt)
{
long component = (long)opt;
int level_to_set = ReturnLevelAscii(param->string);
if (level_to_set == -1)
return -1;
if (component == COMPONENT_ALL)
{
_SetLevelDebug(level_to_set);
LogChanges("SNMP request changing log level for all components to %s",
ReturnLevelInt(level_to_set));
}
else
{
LogChanges("SNMP request changing log level of %s from %s to %s.",
LogComponents[component].comp_name,
ReturnLevelInt(LogComponents[component].comp_log_level),
ReturnLevelInt(level_to_set));
LogComponents[component].comp_log_level = level_to_set;
}
return 0;
}
void InitLogging()
{
int i;
char *env_value;
int newlevel, component, oldlevel;
/* Initialisation du tableau des familys */
tab_family[0].num_family = 0;
tab_family[0].tab_err = (family_error_t *) tab_system_err;
strcpy(tab_family[0].name_family, "Errors Systeme UNIX");
for(i = 1; i < MAX_NUM_FAMILY; i++)
tab_family[i].num_family = UNUSED_SLOT;
ArmSignal(SIGUSR1, IncrementLevelDebug);
ArmSignal(SIGUSR2, DecrementLevelDebug);
for(component = COMPONENT_ALL; component < COMPONENT_COUNT; component++)
{
env_value = getenv(LogComponents[component].comp_name);
if (env_value == NULL)
continue;
newlevel = ReturnLevelAscii(env_value);
if (newlevel == -1) {
LogCrit(COMPONENT_LOG,
"Environment variable %s exists, but the value %s is not a"
" valid log level.",
LogComponents[component].comp_name, env_value);
continue;
}
oldlevel = LogComponents[component].comp_log_level;
LogComponents[component].comp_log_level = newlevel;
LogChanges("Using environment variable to switch log level for %s from "
"%s to %s",
LogComponents[component].comp_name, ReturnLevelInt(oldlevel),
ReturnLevelInt(newlevel));
}
} /* InitLogging */
int main(int argc, char *argv[])
{
char *tempo_exec_name = NULL;
char localmachine[MAXHOSTNAMELEN + 1];
int c;
int pidfile;
#ifndef HAVE_DAEMON
pid_t son_pid;
#endif
sigset_t signals_to_block;
/* Set the server's boot time and epoch */
now(&ServerBootTime);
ServerEpoch = (time_t) ServerBootTime.tv_sec;
tempo_exec_name = strrchr(argv[0], '/');
if (tempo_exec_name != NULL) {
exec_name = gsh_strdup(tempo_exec_name + 1);
if (!exec_name) {
fprintf(stderr,
"Unable to allocate memory for exec name, exiting...\n");
exit(1);
}
}
if (*exec_name == '\0')
exec_name = argv[0];
/* get host name */
if (gethostname(localmachine, sizeof(localmachine)) != 0) {
fprintf(stderr, "Could not get local host name, exiting...\n");
exit(1);
} else {
host_name = gsh_strdup(localmachine);
if (!host_name) {
fprintf(stderr,
"Unable to allocate memory for hostname, exiting...\n");
exit(1);
}
}
/* now parsing options with getopt */
while ((c = getopt(argc, argv, options)) != EOF) {
switch (c) {
case '@':
/* A litlle backdoor to keep track of binary versions */
printf("%s compiled on %s at %s\n", exec_name, __DATE__,
__TIME__);
printf("Release = %s\n", VERSION);
printf("Release comment = %s\n", VERSION_COMMENT);
printf("Git HEAD = %s\n", _GIT_HEAD_COMMIT);
printf("Git Describe = %s\n", _GIT_DESCRIBE);
exit(0);
break;
case 'L':
/* Default Log */
log_path = gsh_strdup(optarg);
if (!log_path) {
fprintf(stderr,
"Unable to allocate memory for log path.\n");
exit(1);
}
break;
case 'N':
/* debug level */
debug_level = ReturnLevelAscii(optarg);
if (debug_level == -1) {
fprintf(stderr,
"Invalid value for option 'N': NIV_NULL, NIV_MAJ, NIV_CRIT, NIV_EVENT, NIV_DEBUG, NIV_MID_DEBUG or NIV_FULL_DEBUG expected.\n");
exit(1);
}
break;
case 'f':
/* config file */
config_path = gsh_strdup(optarg);
if (!config_path) {
fprintf(stderr,
"Unable to allocate memory for config path.\n");
exit(1);
}
break;
case 'p':
/* PID file */
pidfile_path = gsh_strdup(optarg);
if (!pidfile_path) {
fprintf(stderr,
"Path %s too long for option 'f'.\n",
optarg);
exit(1);
}
break;
case 'd':
/* Detach or not detach ? */
detach_flag = true;
break;
case 'R':
/* Shall we manage RPCSEC_GSS ? */
fprintf(stderr,
"\n\nThe -R flag is deprecated, use this syntax in the configuration file instead:\n\n");
fprintf(stderr, "NFS_KRB5\n");
fprintf(stderr, "{\n");
fprintf(stderr,
"\tPrincipalName = nfs@<your_host> ;\n");
fprintf(stderr, "\tKeytabPath = /etc/krb5.keytab ;\n");
fprintf(stderr, "\tActive_krb5 = true ;\n");
fprintf(stderr, "}\n\n\n");
exit(1);
break;
case 'T':
/* Dump the default configuration on stdout */
my_nfs_start_info.dump_default_config = true;
break;
case 'E':
ServerEpoch = (time_t) atoll(optarg);
break;
case '?':
case 'h':
default:
/* display the help */
fprintf(stderr, usage, exec_name);
exit(0);
break;
}
}
/* initialize memory and logging */
nfs_prereq_init(exec_name, host_name, debug_level, log_path);
LogEvent(COMPONENT_MAIN,
"%s Starting: Version %s, built at %s %s on %s",
exec_name, GANESHA_VERSION, __DATE__, __TIME__, BUILD_HOST);
/* Start in background, if wanted */
if (detach_flag) {
#ifdef HAVE_DAEMON
/* daemonize the process (fork, close xterm fds,
* detach from parent process) */
if (daemon(0, 0))
LogFatal(COMPONENT_MAIN,
"Error detaching process from parent: %s",
strerror(errno));
#else
/* Step 1: forking a service process */
switch (son_pid = fork()) {
case -1:
/* Fork failed */
LogFatal(COMPONENT_MAIN,
"Could not start nfs daemon (fork error %d (%s)",
errno, strerror(errno));
break;
case 0:
/* This code is within the son (that will actually work)
* Let's make it the leader of its group of process */
if (setsid() == -1) {
LogFatal(COMPONENT_MAIN,
"Could not start nfs daemon (setsid error %d (%s)",
errno, strerror(errno));
}
break;
default:
/* This code is within the parent process,
* it is useless, it must die */
LogFullDebug(COMPONENT_MAIN,
"Starting a child of pid %d",
son_pid);
exit(0);
break;
}
#endif
}
/* Make sure Linux file i/o will return with error
* if file size is exceeded. */
#ifdef _LINUX
signal(SIGXFSZ, SIG_IGN);
#endif
/* Echo PID into pidfile */
pidfile = open(pidfile_path, O_CREAT | O_RDWR, 0644);
if (pidfile == -1) {
LogFatal(COMPONENT_MAIN, "Can't open pid file %s for writing",
pidfile_path);
} else {
char linebuf[1024];
struct flock lk;
/* Try to obtain a lock on the file */
lk.l_type = F_WRLCK;
lk.l_whence = SEEK_SET;
lk.l_start = (off_t) 0;
lk.l_len = (off_t) 0;
if (fcntl(pidfile, F_SETLK, &lk) == -1)
LogFatal(COMPONENT_MAIN, "Ganesha already started");
/* Put pid into file, then close it */
(void)snprintf(linebuf, sizeof(linebuf), "%u\n", getpid());
if (write(pidfile, linebuf, strlen(linebuf)) == -1)
LogCrit(COMPONENT_MAIN, "Couldn't write pid to file %s",
pidfile_path);
}
/* Set up for the signal handler.
* Blocks the signals the signal handler will handle.
*/
sigemptyset(&signals_to_block);
sigaddset(&signals_to_block, SIGTERM);
sigaddset(&signals_to_block, SIGHUP);
sigaddset(&signals_to_block, SIGPIPE);
if (pthread_sigmask(SIG_BLOCK, &signals_to_block, NULL) != 0)
LogFatal(COMPONENT_MAIN,
"Could not start nfs daemon, pthread_sigmask failed");
/* Parse the configuration file so we all know what is going on. */
if (config_path == NULL) {
LogFatal(COMPONENT_INIT,
"start_fsals: No configuration file named.");
return 1;
}
config_struct = config_ParseFile(config_path);
if (!config_struct) {
LogFatal(COMPONENT_INIT, "Error while parsing %s: %s",
config_path, config_GetErrorMsg());
}
/* We need all the fsal modules loaded so we can have
* the list available at exports parsing time.
*/
start_fsals(config_struct);
/* parse configuration file */
if (nfs_set_param_from_conf(config_struct, &my_nfs_start_info)) {
LogFatal(COMPONENT_INIT,
"Error setting parameters from configuration file.");
}
if (nfs_check_param_consistency()) {
LogFatal(COMPONENT_INIT,
"Inconsistent parameters found. Exiting...");
}
if (init_fsals(config_struct)) { /* init the FSALs from the config */
LogFatal(COMPONENT_INIT,
"FSALs could not initialize. Exiting...");
}
/* freeing syntax tree : */
config_Free(config_struct);
/* Everything seems to be OK! We can now start service threads */
nfs_start(&my_nfs_start_info);
return 0;
}
fsal_status_t LUSTREFSAL_load_FSAL_parameter_from_conf(config_file_t in_config,
fsal_parameter_t * out_parameter)
{
int err;
int var_max, var_index;
char *key_name;
char *key_value;
config_item_t block;
int DebugLevel = -1;
char *LogFile = NULL;
block = config_FindItemByName(in_config, CONF_LABEL_FSAL);
/* cannot read item */
if(block == NULL)
{
LogCrit(COMPONENT_FSAL,"FSAL LOAD PARAMETER: Cannot read item \"%s\" from configuration file",
CONF_LABEL_FSAL);
ReturnCode(ERR_FSAL_NOENT, 0);
}
else if(config_ItemType(block) != CONFIG_ITEM_BLOCK)
{
LogCrit(COMPONENT_FSAL,"FSAL LOAD PARAMETER: Item \"%s\" is expected to be a block",
CONF_LABEL_FSAL);
ReturnCode(ERR_FSAL_INVAL, 0);
}
/* read variable for fsal init */
var_max = config_GetNbItems(block);
for(var_index = 0; var_index < var_max; var_index++)
{
config_item_t item;
item = config_GetItemByIndex(block, var_index);
err = config_GetKeyValue(item, &key_name, &key_value);
if(err)
{
LogCrit(COMPONENT_FSAL,
"FSAL LOAD PARAMETER: ERROR reading key[%d] from section \"%s\" of configuration file.",
var_index, CONF_LABEL_FSAL);
ReturnCode(ERR_FSAL_SERVERFAULT, err);
}
if(!STRCMP(key_name, "DebugLevel"))
{
DebugLevel = ReturnLevelAscii(key_value);
if(DebugLevel == -1)
{
LogCrit(COMPONENT_FSAL,"FSAL LOAD PARAMETER: ERROR: Invalid debug level name: \"%s\".",
key_value);
ReturnCode(ERR_FSAL_INVAL, -1);
}
}
else if(!STRCMP(key_name, "LogFile"))
{
LogFile = key_value;
}
else if(!STRCMP(key_name, "Max_FS_calls"))
{
int maxcalls = s_read_int(key_value);
if(maxcalls < 0)
{
LogCrit(COMPONENT_FSAL,
"FSAL LOAD PARAMETER: ERROR: Unexpected value for %s: null or positive integer expected.",
key_name);
ReturnCode(ERR_FSAL_INVAL, 0);
}
out_parameter->fsal_info.max_fs_calls = (unsigned int)maxcalls;
}
else
{
LogCrit(COMPONENT_FSAL,
"FSAL LOAD PARAMETER: ERROR: Unknown or unsettable key: %s (item %s)",
key_name, CONF_LABEL_FSAL);
ReturnCode(ERR_FSAL_INVAL, 0);
}
}
/* init logging */
if(LogFile)
SetComponentLogFile(COMPONENT_FSAL, LogFile);
if(DebugLevel != -1)
SetComponentLogLevel(COMPONENT_FSAL, DebugLevel);
ReturnCode(ERR_FSAL_NO_ERROR, 0);
} /* FSAL_load_FSAL_parameter_from_conf */
/*
*
* cache_content_read_conf_client_parameter: read the configuration for a client to File Content layer.
*
* Reads the configuration for a client to File Content layer (typically a worker thread).
*
* @param in_config [IN] configuration file handle
* @param pparam [OUT] read parameters
*
* @return CACHE_CONTENT_SUCCESS if ok, CACHE_CONTENT_INVALID_ARGUMENT otherwise.
*
*/
cache_content_status_t cache_content_read_conf_client_parameter(config_file_t in_config,
cache_content_client_parameter_t * pparam)
{
int var_max;
int var_index;
int err;
char *key_name;
char *key_value;
config_item_t block;
int DebugLevel = -1;
char *LogFile = NULL;
/* Is the config tree initialized ? */
if(in_config == NULL || pparam == NULL)
return CACHE_CONTENT_INVALID_ARGUMENT;
/* Get the config BLOCK */
if((block = config_FindItemByName(in_config, CONF_LABEL_CACHE_CONTENT_CLIENT)) == NULL)
{
/* fprintf(stderr, "Cannot read item \"%s\" from configuration file\n", CONF_LABEL_CACHE_CONTENT_CLIENT ) ; */
return CACHE_CONTENT_NOT_FOUND;
}
else if(config_ItemType(block) != CONFIG_ITEM_BLOCK)
{
/* Expected to be a block */
return CACHE_CONTENT_INVALID_ARGUMENT;
}
var_max = config_GetNbItems(block);
for(var_index = 0; var_index < var_max; var_index++)
{
config_item_t item;
item = config_GetItemByIndex(block, var_index);
/* Get key's name */
if((err = config_GetKeyValue(item, &key_name, &key_value)) != 0)
{
fprintf(stderr,
"Error reading key[%d] from section \"%s\" of configuration file.\n",
var_index, CONF_LABEL_CACHE_CONTENT_CLIENT);
return CACHE_CONTENT_INVALID_ARGUMENT;
}
if(!strcasecmp(key_name, "LRU_Prealloc_PoolSize")) /** @todo: BUGAZOMEU: to be removed */
{
//pparam->lru_param.nb_entry_prealloc = atoi( key_value ) ;
}
else if(!strcasecmp(key_name, "LRU_Nb_Call_Gc_invalid")) /** @todo: BUGAZOMEU: to be removed */
{
//pparam->lru_param.nb_call_gc_invalid = atoi( key_value ) ;
}
else if(!strcasecmp(key_name, "Entry_Prealloc_PoolSize")) /** @todo: BUGAZOMEU: to be removed */
{
pparam->nb_prealloc_entry = atoi(key_value);
}
else if(!strcasecmp(key_name, "Cache_Directory"))
{
strcpy(pparam->cache_dir, key_value);
}
else if(!strcasecmp(key_name, "Refresh_FSAL_Force"))
{
pparam->flush_force_fsal = atoi(key_value);
}
else if(!strcasecmp(key_name, "DebugLevel"))
{
DebugLevel = ReturnLevelAscii(key_value);
if(DebugLevel == -1)
{
LogCrit(COMPONENT_CACHE_CONTENT,
"cache_content_read_conf: ERROR: Invalid debug level name: \"%s\".",
key_value);
return CACHE_CONTENT_INVALID_ARGUMENT;
}
}
else if(!strcasecmp(key_name, "LogFile"))
{
LogFile = key_value;
}
else if(!strcasecmp(key_name, "Max_Fd"))
{
pparam->max_fd = atoi(key_value);
}
else if(!strcasecmp(key_name, "OpenFile_Retention"))
{
pparam->retention = atoi(key_value);
}
else if(!strcasecmp(key_name, "Use_OpenClose_cache"))
{
pparam->use_fd_cache = StrToBoolean(key_value);
}
else
{
fprintf(stderr,
"Unknown or unsettable key: %s (item %s)\n",
key_name, CONF_LABEL_CACHE_CONTENT_CLIENT);
return CACHE_CONTENT_INVALID_ARGUMENT;
}
}
fcc_debug_level = DebugLevel;
if(LogFile) {
LogEvent(COMPONENT_INIT, "Setting log file of emergency cache flush thread to %s",
LogFile);
strncpy(fcc_log_path, LogFile, MAXPATHLEN);
}
else {
LogDebug(COMPONENT_INIT, "No log file set for emergency cache flush thread in configuration. Setting to default.") ;
strncpy(fcc_log_path, "/dev/null", MAXPATHLEN);
}
/* init logging */
if(LogFile)
SetComponentLogFile(COMPONENT_CACHE_CONTENT, LogFile);
if(DebugLevel > -1)
SetComponentLogLevel(COMPONENT_CACHE_CONTENT, DebugLevel);
return CACHE_CONTENT_SUCCESS;
} /* cache_content_read_conf_client_parameter */
/**
* Tests about Log streams and special printf functions.
*/
void Test1(char *str, char *file)
{
char tempstr[2048];
struct display_buffer buffer = { sizeof(tempstr), tmpstr, tmpstr };
int i;
SetComponentLogFile(COMPONENT_INIT, "STDOUT");
LogAlways(COMPONENT_INIT, "%s", "Starting Log Tests");
LogTest("My PID = %d", getpid());
LogTest("------------------------------------------------------");
LogTest("Test conversion of log levels between string and integer");
for (i = NIV_NULL; i < NB_LOG_LEVEL; i++) {
int j;
if (strcmp(tabLogLevel[i].str, ReturnLevelInt(i)) != 0) {
LogTest(
"FAILURE: Log level %d did not convert to %s, it converted to %s",
i, tabLogLevel[i].str, ReturnLevelInt(i));
exit(1);
}
j = ReturnLevelAscii(tabLogLevel[i].str);
if (j != i) {
LogTest(
"FAILURE: Log level %s did not convert to %d, it converted to %d",
tabLogLevel[i].str, i, j);
exit(1);
}
}
LogTest("------------------------------------------------------");
LogTest("\nTesting possible environment variable");
LogTest("COMPONENT_MEMCORRUPT debug level is %s",
ReturnLevelInt(LogComponents[COMPONENT_MEMCORRUPT].
comp_log_level));
LogFullDebug(COMPONENT_MEMCORRUPT,
"This should appear if environment is set properly");
LogTest("------------------------------------------------------");
LogTest("Send some messages to various files");
SetComponentLogFile(COMPONENT_DISPATCH, "STDERR");
LogEvent(COMPONENT_DISPATCH, "This should go to stderr");
SetComponentLogFile(COMPONENT_DISPATCH, "STDOUT");
LogEvent(COMPONENT_DISPATCH, "This should go to stdout");
SetComponentLogFile(COMPONENT_DISPATCH, "SYSLOG");
LogEvent(COMPONENT_DISPATCH, "This should go to syslog (verf = %s)",
str);
LogTest("About to set %s", file);
SetComponentLogFile(COMPONENT_DISPATCH, file);
LogTest("Got it set");
LogEvent(COMPONENT_DISPATCH, "This should go to %s", file);
/* Set up for tests that will verify what was actually produced by log
* messages. This is used to test log levels and to test the
* log_vnsprintf function.
*/
/** @todo FSF: this can be done by setting the right header flags and
* peeking at the context buffer.
*/
SetComponentLogBuffer(COMPONENT_MAIN, &buffer);
SetComponentLogBuffer(COMPONENT_INIT, &buffer);
LogTest("------------------------------------------------------");
LogTest("Test all levels of log filtering");
SetComponentLogLevel(COMPONENT_MAIN, NIV_NULL);
TestAlways(true, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor(false, tempstr, COMPONENT_MAIN, "LogMajor (shouldn't print)");
TestCrit(false, tempstr, COMPONENT_MAIN, "LogCrit (shouldn't print)");
TestEvent(false, tempstr, COMPONENT_MAIN, "LogEvent (shouldn't print)");
TestDebug(false, tempstr, COMPONENT_MAIN, "LogDebug (shouldn't print)");
TestFullDebug(false, tempstr, COMPONENT_MAIN,
"LogFullDebug (shouldn't print)");
SetComponentLogLevel(COMPONENT_MAIN, NIV_MAJOR);
TestAlways(true, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor(true, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit(false, tempstr, COMPONENT_MAIN, "LogCrit (shouldn't print)");
TestEvent(false, tempstr, COMPONENT_MAIN, "LogEvent (shouldn't print)");
TestDebug(false, tempstr, COMPONENT_MAIN, "LogDebug (shouldn't print)");
TestFullDebug(false, tempstr, COMPONENT_MAIN,
"LogFullDebug (shouldn't print)");
SetComponentLogLevel(COMPONENT_MAIN, NIV_CRIT);
TestAlways(true, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor(true, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit(true, tempstr, COMPONENT_MAIN, "LogCrit (should print)");
TestEvent(false, tempstr, COMPONENT_MAIN, "LogEvent (shouldn't print)");
TestDebug(false, tempstr, COMPONENT_MAIN, "LogDebug (shouldn't print)");
TestFullDebug(false, tempstr, COMPONENT_MAIN,
"LogFullDebug (shouldn't print)");
SetComponentLogLevel(COMPONENT_MAIN, NIV_EVENT);
TestAlways(true, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor(true, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit(true, tempstr, COMPONENT_MAIN, "LogCrit (should print)");
TestEvent(true, tempstr, COMPONENT_MAIN, "LogEvent (should print)");
TestDebug(false, tempstr, COMPONENT_MAIN, "LogDebug (shouldn't print)");
TestFullDebug(false, tempstr, COMPONENT_MAIN,
"LogFullDebug (shouldn't print)");
SetComponentLogLevel(COMPONENT_MAIN, NIV_DEBUG);
TestAlways(true, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor(true, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit(true, tempstr, COMPONENT_MAIN, "LogCrit (should print)");
TestEvent(true, tempstr, COMPONENT_MAIN, "LogEvent (should print)");
TestDebug(true, tempstr, COMPONENT_MAIN, "LogDebug (should print)");
TestFullDebug(false, tempstr, COMPONENT_MAIN,
"LogFullDebug (shouldn't print)");
SetComponentLogLevel(COMPONENT_MAIN, NIV_FULL_DEBUG);
TestAlways(true, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor(true, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit(true, tempstr, COMPONENT_MAIN, "LogCrit (should print)");
TestEvent(true, tempstr, COMPONENT_MAIN, "LogEvent (should print)");
TestDebug(true, tempstr, COMPONENT_MAIN, "LogDebug (should print)");
TestFullDebug(true, tempstr, COMPONENT_MAIN,
"LogFullDebug (should print)");
}
/**
* Tests about Log streams and special printf functions.
*/
int Test1(char *str, char *file)
{
char tempstr[2048];
int i;
SetComponentLogFile(COMPONENT_INIT, "STDOUT");
LogAlways(COMPONENT_INIT, "%s", "Starting Log Tests");
LogTest("My PID = %d", getpid());
LogTest("------------------------------------------------------");
LogTest("Test ERR_DUMMY");
LogTest("A numerical error : error %%d = %%J%%R, in ERR_DUMMY_2 %%J%%R");
log_snprintf(tempstr, sizeof(tempstr),
"A numerical error : error %d = %J%R, in ERR_DUMMY_2 %J%R",
ERR_SIGACTION, ERR_SYS, ERR_SIGACTION, ERR_DUMMY, ERR_DUMMY_2);
LogTest("%s", tempstr);
LogTest("A numerical error : error %d = %J%R, in ERR_DUMMY_1 %J%R",
ERR_OPEN, ERR_SYS, ERR_OPEN, ERR_DUMMY, ERR_DUMMY_1);
LogTest("------------------------------------------------------");
LogTest("Test conversion of log levels between string and integer");
for (i = NIV_NULL; i < NB_LOG_LEVEL; i++)
{
int j;
if (strcmp(tabLogLevel[i].str, ReturnLevelInt(i)) != 0)
{
LogTest("FAILURE: Log level %d did not convert to %s, it converted to %s",
i, tabLogLevel[i].str, ReturnLevelInt(i));
exit(1);
}
j = ReturnLevelAscii(tabLogLevel[i].str);
if (j != i)
{
LogTest("FAILURE: Log level %s did not convert to %d, it converted to %d",
tabLogLevel[i].str, i, j);
exit(1);
}
}
LogTest("------------------------------------------------------");
log_snprintf(tempstr, sizeof(tempstr), "Test log_snprintf");
LogTest("%s", tempstr);
LogTest("\nTesting LogError function");
LogError(COMPONENT_CONFIG, ERR_SYS, ERR_MALLOC, EINVAL);
LogTest("\nTesting possible environment variable");
LogTest("COMPONENT_MEMCORRUPT debug level is %s",
ReturnLevelInt(LogComponents[COMPONENT_MEMCORRUPT].comp_log_level));
LogFullDebug(COMPONENT_MEMCORRUPT,
"This should appear if environment is set properly");
LogTest("------------------------------------------------------");
LogTest("Send some messages to various files");
SetComponentLogFile(COMPONENT_DISPATCH, "STDERR");
LogEvent(COMPONENT_DISPATCH, "This should go to stderr");
SetComponentLogFile(COMPONENT_DISPATCH, "STDOUT");
LogEvent(COMPONENT_DISPATCH, "This should go to stdout");
SetComponentLogFile(COMPONENT_DISPATCH, "SYSLOG");
LogEvent(COMPONENT_DISPATCH, "This should go to syslog (verf = %s)", str);
LogTest("About to set %s", file);
SetComponentLogFile(COMPONENT_DISPATCH, file);
LogTest("Got it set");
LogEvent(COMPONENT_DISPATCH, "This should go to %s", file);
/*
* Set up for tests that will verify what was actually produced by log messages.
* This is used to test log levels and to test the log_vnsprintf function.
*/
SetComponentLogBuffer(COMPONENT_MAIN, tempstr);
SetComponentLogBuffer(COMPONENT_INIT, tempstr);
#ifdef _SNMP_ADM_ACTIVE
{
snmp_adm_type_union param;
int rc;
strcpy(param.string, "FAILED");
LogTest("------------------------------------------------------");
LogTest("Test SNMP functions");
SetLevelDebug(NIV_DEBUG);
rc = getComponentLogLevel(¶m, (void *)COMPONENT_ALL);
LogTest("getComponentLogLevel(¶m, (void *)COMPONENT_ALL) rc=%d result=%s",
rc, param.string);
if (rc != 0)
{
LogTest("FAILURE");
exit(1);
}
strcpy(param.string, "NIV_EVENT");
rc = setComponentLogLevel(¶m, (void *)COMPONENT_MAIN);
LogTest("setComponentLogLevel(¶m, (void *)COMPONENT_MAIN) rc=%d", rc);
if (rc != 0)
{
LogTest("FAILURE");
exit(1);
}
TestAlways (TRUE, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor (TRUE, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit (TRUE, tempstr, COMPONENT_MAIN, "LogCrit (should print)");
TestEvent (TRUE, tempstr, COMPONENT_MAIN, "LogEvent (should print)");
TestDebug (FALSE, tempstr, COMPONENT_MAIN, "LogDebug (shouldn't print)");
TestFullDebug (FALSE, tempstr, COMPONENT_MAIN, "LogFullDebug (shouldn't print)");
TestAlways (TRUE, tempstr, COMPONENT_INIT, "LogAlways (should print)");
TestMajor (TRUE, tempstr, COMPONENT_INIT, "LogMajor (should print)");
TestCrit (TRUE, tempstr, COMPONENT_INIT, "LogCrit (should print)");
TestEvent (TRUE, tempstr, COMPONENT_INIT, "LogEvent (should print)");
TestDebug (TRUE, tempstr, COMPONENT_INIT, "LogDebug (should print)");
TestFullDebug (FALSE, tempstr, COMPONENT_INIT, "LogFullDebug (shouldn't print)");
}
#endif /* _SNMP_ADM_ACTIVE */
LogTest("------------------------------------------------------");
LogTest("Test all levels of log filtering");
SetComponentLogLevel(COMPONENT_MAIN, NIV_NULL);
TestAlways (TRUE, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor (FALSE, tempstr, COMPONENT_MAIN, "LogMajor (shouldn't print)");
TestCrit (FALSE, tempstr, COMPONENT_MAIN, "LogCrit (shouldn't print)");
TestEvent (FALSE, tempstr, COMPONENT_MAIN, "LogEvent (shouldn't print)");
TestDebug (FALSE, tempstr, COMPONENT_MAIN, "LogDebug (shouldn't print)");
TestFullDebug (FALSE, tempstr, COMPONENT_MAIN, "LogFullDebug (shouldn't print)");
SetComponentLogLevel(COMPONENT_MAIN, NIV_MAJOR);
TestAlways (TRUE, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor (TRUE, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit (FALSE, tempstr, COMPONENT_MAIN, "LogCrit (shouldn't print)");
TestEvent (FALSE, tempstr, COMPONENT_MAIN, "LogEvent (shouldn't print)");
TestDebug (FALSE, tempstr, COMPONENT_MAIN, "LogDebug (shouldn't print)");
TestFullDebug (FALSE, tempstr, COMPONENT_MAIN, "LogFullDebug (shouldn't print)");
SetComponentLogLevel(COMPONENT_MAIN, NIV_CRIT);
TestAlways (TRUE, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor (TRUE, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit (TRUE, tempstr, COMPONENT_MAIN, "LogCrit (should print)");
TestEvent (FALSE, tempstr, COMPONENT_MAIN, "LogEvent (shouldn't print)");
TestDebug (FALSE, tempstr, COMPONENT_MAIN, "LogDebug (shouldn't print)");
TestFullDebug (FALSE, tempstr, COMPONENT_MAIN, "LogFullDebug (shouldn't print)");
SetComponentLogLevel(COMPONENT_MAIN, NIV_EVENT);
TestAlways (TRUE, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor (TRUE, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit (TRUE, tempstr, COMPONENT_MAIN, "LogCrit (should print)");
TestEvent (TRUE, tempstr, COMPONENT_MAIN, "LogEvent (should print)");
TestDebug (FALSE, tempstr, COMPONENT_MAIN, "LogDebug (shouldn't print)");
TestFullDebug (FALSE, tempstr, COMPONENT_MAIN, "LogFullDebug (shouldn't print)");
SetComponentLogLevel(COMPONENT_MAIN, NIV_DEBUG);
TestAlways (TRUE, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor (TRUE, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit (TRUE, tempstr, COMPONENT_MAIN, "LogCrit (should print)");
TestEvent (TRUE, tempstr, COMPONENT_MAIN, "LogEvent (should print)");
TestDebug (TRUE, tempstr, COMPONENT_MAIN, "LogDebug (should print)");
TestFullDebug (FALSE, tempstr, COMPONENT_MAIN, "LogFullDebug (shouldn't print)");
SetComponentLogLevel(COMPONENT_MAIN, NIV_FULL_DEBUG);
TestAlways (TRUE, tempstr, COMPONENT_MAIN, "LogAlways (should print)");
TestMajor (TRUE, tempstr, COMPONENT_MAIN, "LogMajor (should print)");
TestCrit (TRUE, tempstr, COMPONENT_MAIN, "LogCrit (should print)");
TestEvent (TRUE, tempstr, COMPONENT_MAIN, "LogEvent (should print)");
TestDebug (TRUE, tempstr, COMPONENT_MAIN, "LogDebug (should print)");
TestFullDebug (TRUE, tempstr, COMPONENT_MAIN, "LogFullDebug (should print)");
}
int _9p_read_conf( config_file_t in_config,
_9p_parameter_t *pparam )
{
int var_max;
int var_index;
int err;
char *key_name;
char *key_value;
config_item_t block;
int DebugLevel = -1;
char *LogFile = NULL;
/* Is the config tree initialized ? */
if(in_config == NULL || pparam == NULL)
return -1 ;
/* Get the config BLOCK */
if((block = config_FindItemByName(in_config, CONF_LABEL_9P )) == NULL)
return -2 ; /* no 9P config, use default */
else if(config_ItemType(block) != CONFIG_ITEM_BLOCK)
return -1 ;
var_max = config_GetNbItems(block);
for(var_index = 0; var_index < var_max; var_index++)
{
config_item_t item;
item = config_GetItemByIndex(block, var_index);
/* Get key's name */
if((err = config_GetKeyValue(item, &key_name, &key_value)) != 0)
{
fprintf(stderr,
"Error reading key[%d] from section \"%s\" of configuration file.\n",
var_index, CONF_LABEL_9P );
return -1 ;
}
if(!strcasecmp(key_name, "_9P_Port"))
{
pparam->_9p_port = atoi( key_value ) ;
}
else if(!strcasecmp(key_name, "DebugLevel"))
{
DebugLevel = ReturnLevelAscii(key_value);
if(DebugLevel == -1)
{
fprintf(stderr,
"9P: ERROR: Invalid debug level name: \"%s\".",
key_value);
return -1 ;
}
}
else if(!strcasecmp(key_name, "LogFile"))
{
LogFile = key_value;
}
else
{
fprintf(stderr,
"Unknown or unsettable key: %s (item %s)\n",
key_name, CONF_LABEL_9P);
return -1 ;
}
} /* for */
/* init logging */
if(LogFile)
SetComponentLogFile(COMPONENT_9P, LogFile);
if(DebugLevel > -1)
SetComponentLogLevel(COMPONENT_9P, DebugLevel);
return 0 ;
} /* _9p_read_conf */
int main(int argc, char *argv[])
{
char *tempo_exec_name = NULL;
char localmachine[MAXHOSTNAMELEN + 1];
int c;
int dsc;
int rc;
int pidfile;
char *log_path = NULL;
char *exec_name = "nfs-ganesha";
int debug_level = -1;
int detach_flag = true;
bool dump_trace = false;
#ifndef HAVE_DAEMON
int dev_null_fd = 0;
pid_t son_pid;
#endif
sigset_t signals_to_block;
struct config_error_type err_type;
/* Set the server's boot time and epoch */
now(&nfs_ServerBootTime);
nfs_ServerEpoch = (time_t) nfs_ServerBootTime.tv_sec;
srand(nfs_ServerEpoch);
tempo_exec_name = strrchr(argv[0], '/');
if (tempo_exec_name != NULL)
exec_name = main_strdup("exec_name", tempo_exec_name + 1);
if (*exec_name == '\0')
exec_name = argv[0];
/* get host name */
if (gethostname(localmachine, sizeof(localmachine)) != 0) {
fprintf(stderr, "Could not get local host name, exiting...\n");
exit(1);
} else {
nfs_host_name = main_strdup("host_name", localmachine);
}
/* now parsing options with getopt */
while ((c = getopt(argc, argv, options)) != EOF) {
switch (c) {
case 'v':
case '@':
printf("NFS-Ganesha Release = V%s\n", GANESHA_VERSION);
#if !GANESHA_BUILD_RELEASE
/* A little backdoor to keep track of binary versions */
printf("%s compiled on %s at %s\n", exec_name, __DATE__,
__TIME__);
printf("Release comment = %s\n", VERSION_COMMENT);
printf("Git HEAD = %s\n", _GIT_HEAD_COMMIT);
printf("Git Describe = %s\n", _GIT_DESCRIBE);
#endif
exit(0);
break;
case 'L':
/* Default Log */
log_path = main_strdup("log_path", optarg);
break;
case 'N':
/* debug level */
debug_level = ReturnLevelAscii(optarg);
if (debug_level == -1) {
fprintf(stderr,
"Invalid value for option 'N': NIV_NULL, NIV_MAJ, NIV_CRIT, NIV_EVENT, NIV_DEBUG, NIV_MID_DEBUG or NIV_FULL_DEBUG expected.\n");
exit(1);
}
break;
case 'f':
/* config file */
nfs_config_path = main_strdup("config_path", optarg);
break;
case 'p':
/* PID file */
nfs_pidfile_path = main_strdup("pidfile_path", optarg);
break;
case 'F':
/* Don't detach, foreground mode */
detach_flag = false;
break;
case 'R':
/* Shall we manage RPCSEC_GSS ? */
fprintf(stderr,
"\n\nThe -R flag is deprecated, use this syntax in the configuration file instead:\n\n");
fprintf(stderr, "NFS_KRB5\n");
fprintf(stderr, "{\n");
fprintf(stderr,
"\tPrincipalName = nfs@<your_host> ;\n");
fprintf(stderr, "\tKeytabPath = /etc/krb5.keytab ;\n");
fprintf(stderr, "\tActive_krb5 = true ;\n");
fprintf(stderr, "}\n\n\n");
exit(1);
break;
case 'T':
/* Dump the default configuration on stdout */
my_nfs_start_info.dump_default_config = true;
break;
case 'C':
dump_trace = true;
break;
case 'E':
nfs_ServerEpoch = (time_t) atoll(optarg);
break;
case 'h':
fprintf(stderr, usage, exec_name);
exit(0);
default: /* '?' */
fprintf(stderr, "Try '%s -h' for usage\n", exec_name);
exit(1);
}
}
/* initialize memory and logging */
nfs_prereq_init(exec_name, nfs_host_name, debug_level, log_path,
dump_trace);
#if GANESHA_BUILD_RELEASE
LogEvent(COMPONENT_MAIN, "%s Starting: Ganesha Version %s",
exec_name, GANESHA_VERSION);
#else
LogEvent(COMPONENT_MAIN, "%s Starting: %s",
exec_name,
"Ganesha Version " _GIT_DESCRIBE ", built at "
__DATE__ " " __TIME__ " on " BUILD_HOST);
#endif
/* initialize nfs_init */
nfs_init_init();
nfs_check_malloc();
/* Start in background, if wanted */
if (detach_flag) {
#ifdef HAVE_DAEMON
/* daemonize the process (fork, close xterm fds,
* detach from parent process) */
if (daemon(0, 0))
LogFatal(COMPONENT_MAIN,
"Error detaching process from parent: %s",
strerror(errno));
/* In the child process, change the log header
* if not, the header will contain the parent's pid */
set_const_log_str();
#else
/* Step 1: forking a service process */
switch (son_pid = fork()) {
case -1:
/* Fork failed */
LogFatal(COMPONENT_MAIN,
"Could not start nfs daemon (fork error %d (%s)",
errno, strerror(errno));
break;
case 0:
/* This code is within the son (that will actually work)
* Let's make it the leader of its group of process */
if (setsid() == -1) {
LogFatal(COMPONENT_MAIN,
"Could not start nfs daemon (setsid error %d (%s)",
errno, strerror(errno));
}
/* stdin, stdout and stderr should not refer to a tty
* I close 0, 1 & 2 and redirect them to /dev/null */
dev_null_fd = open("/dev/null", O_RDWR);
if (dev_null_fd < 0)
LogFatal(COMPONENT_MAIN,
"Could not open /dev/null: %d (%s)",
errno, strerror(errno));
if (close(STDIN_FILENO) == -1)
LogEvent(COMPONENT_MAIN,
"Error while closing stdin: %d (%s)",
errno, strerror(errno));
else {
LogEvent(COMPONENT_MAIN, "stdin closed");
dup(dev_null_fd);
}
if (close(STDOUT_FILENO) == -1)
LogEvent(COMPONENT_MAIN,
"Error while closing stdout: %d (%s)",
errno, strerror(errno));
else {
LogEvent(COMPONENT_MAIN, "stdout closed");
dup(dev_null_fd);
}
if (close(STDERR_FILENO) == -1)
LogEvent(COMPONENT_MAIN,
"Error while closing stderr: %d (%s)",
errno, strerror(errno));
else {
LogEvent(COMPONENT_MAIN, "stderr closed");
dup(dev_null_fd);
}
if (close(dev_null_fd) == -1)
LogFatal(COMPONENT_MAIN,
"Could not close tmp fd to /dev/null: %d (%s)",
errno, strerror(errno));
/* In the child process, change the log header
* if not, the header will contain the parent's pid */
set_const_log_str();
break;
default:
/* This code is within the parent process,
* it is useless, it must die */
LogFullDebug(COMPONENT_MAIN,
"Starting a child of pid %d",
son_pid);
exit(0);
break;
}
#endif
}
/* Make sure Linux file i/o will return with error
* if file size is exceeded. */
#ifdef _LINUX
signal(SIGXFSZ, SIG_IGN);
#endif
/* Echo PID into pidfile */
pidfile = open(nfs_pidfile_path, O_CREAT | O_RDWR, 0644);
if (pidfile == -1) {
LogFatal(COMPONENT_MAIN, "Can't open pid file %s for writing",
nfs_pidfile_path);
} else {
char linebuf[1024];
struct flock lk;
/* Try to obtain a lock on the file */
lk.l_type = F_WRLCK;
lk.l_whence = SEEK_SET;
lk.l_start = (off_t) 0;
lk.l_len = (off_t) 0;
if (fcntl(pidfile, F_SETLK, &lk) == -1)
LogFatal(COMPONENT_MAIN, "Ganesha already started");
/* Put pid into file, then close it */
(void)snprintf(linebuf, sizeof(linebuf), "%u\n", getpid());
if (write(pidfile, linebuf, strlen(linebuf)) == -1)
LogCrit(COMPONENT_MAIN, "Couldn't write pid to file %s",
nfs_pidfile_path);
}
/* Set up for the signal handler.
* Blocks the signals the signal handler will handle.
*/
sigemptyset(&signals_to_block);
sigaddset(&signals_to_block, SIGTERM);
sigaddset(&signals_to_block, SIGHUP);
sigaddset(&signals_to_block, SIGPIPE);
if (pthread_sigmask(SIG_BLOCK, &signals_to_block, NULL) != 0)
LogFatal(COMPONENT_MAIN,
"Could not start nfs daemon, pthread_sigmask failed");
/* init URL package */
config_url_init();
/* Create a memstream for parser+processing error messages */
if (!init_error_type(&err_type))
goto fatal_die;
/* Parse the configuration file so we all know what is going on. */
if (nfs_config_path == NULL || nfs_config_path[0] == '\0') {
LogWarn(COMPONENT_INIT,
"No configuration file named.");
nfs_config_struct = NULL;
} else
nfs_config_struct =
config_ParseFile(nfs_config_path, &err_type);
if (!config_error_no_error(&err_type)) {
char *errstr = err_type_str(&err_type);
if (!config_error_is_harmless(&err_type)) {
LogCrit(COMPONENT_INIT,
"Error %s while parsing (%s)",
errstr != NULL ? errstr : "unknown",
nfs_config_path);
if (errstr != NULL)
gsh_free(errstr);
goto fatal_die;
} else
LogWarn(COMPONENT_INIT,
"Error %s while parsing (%s)",
errstr != NULL ? errstr : "unknown",
nfs_config_path);
if (errstr != NULL)
gsh_free(errstr);
}
if (read_log_config(nfs_config_struct, &err_type) < 0) {
LogCrit(COMPONENT_INIT,
"Error while parsing log configuration");
goto fatal_die;
}
/* We need all the fsal modules loaded so we can have
* the list available at exports parsing time.
*/
start_fsals();
/* parse configuration file */
if (nfs_set_param_from_conf(nfs_config_struct,
&my_nfs_start_info,
&err_type)) {
LogCrit(COMPONENT_INIT,
"Error setting parameters from configuration file.");
goto fatal_die;
}
/* initialize core subsystems and data structures */
if (init_server_pkgs() != 0) {
LogCrit(COMPONENT_INIT,
"Failed to initialize server packages");
goto fatal_die;
}
/* Load Data Server entries from parsed file
* returns the number of DS entries.
*/
dsc = ReadDataServers(nfs_config_struct, &err_type);
if (dsc < 0) {
LogCrit(COMPONENT_INIT,
"Error while parsing DS entries");
goto fatal_die;
}
/* Create stable storage directory, this needs to be done before
* starting the recovery thread.
*/
rc = nfs4_recovery_init();
if (rc) {
LogCrit(COMPONENT_INIT,
"Recovery backend initialization failed!");
goto fatal_die;
}
/* Start grace period */
nfs_start_grace(NULL);
/* Wait for enforcement to begin */
nfs_wait_for_grace_enforcement();
/* Load export entries from parsed file
* returns the number of export entries.
*/
rc = ReadExports(nfs_config_struct, &err_type);
if (rc < 0) {
LogCrit(COMPONENT_INIT,
"Error while parsing export entries");
goto fatal_die;
}
if (rc == 0 && dsc == 0)
LogWarn(COMPONENT_INIT,
"No export entries found in configuration file !!!");
report_config_errors(&err_type, NULL, config_errs_to_log);
/* freeing syntax tree : */
config_Free(nfs_config_struct);
/* Everything seems to be OK! We can now start service threads */
nfs_start(&my_nfs_start_info);
return 0;
fatal_die:
report_config_errors(&err_type, NULL, config_errs_to_log);
LogFatal(COMPONENT_INIT,
"Fatal errors. Server exiting...");
/* NOT REACHED */
return 2;
}
int ganefuse_main(int argc, char *argv[],
const struct ganefuse_operations *op, void *user_data)
{
char *tempo_exec_name = NULL;
char localmachine[MAXHOSTNAMELEN];
int c;
pid_t son_pid;
int argc_local = argc;
char **argv_local = argv;
/* local copy for keeping it read only */
ops = *op;
/* retrieve executable file's name */
strncpy(ganesha_exec_path, argv[0], MAXPATHLEN);
if((tempo_exec_name = strrchr(argv_local[0], '/')) != NULL)
strcpy((char *)exec_name, tempo_exec_name + 1);
if(*exec_name == '\0')
strcpy((char *)exec_name, argv_local[0]);
/* get host name */
if(gethostname(localmachine, sizeof(localmachine)) != 0)
{
fprintf(stderr, "Could not get local host name, exiting...");
exit(1);
}
else
strncpy(host_name, localmachine, MAXHOSTNAMELEN);
/* now parsing options with getopt */
while((c = getopt(argc_local, argv_local, options)) != EOF)
{
switch (c)
{
case '@':
/* A litlle backdoor to keep track of binary versions */
printf("%s compiled on %s at %s\n", exec_name, __DATE__, __TIME__);
printf("Release = %s\n", VERSION);
printf("Release comment = %s\n", VERSION_COMMENT);
exit(0);
break;
case 'L':
/* Default Log */
strncpy(log_path, optarg, MAXPATHLEN);
break;
case 'N':
/* debug level */
debug_level = ReturnLevelAscii(optarg);
if(debug_level == -1)
{
fprintf(stderr,
"Invalid value for option 'N': NIV_NULL, NIV_MAJ, NIV_CRIT, NIV_EVENT, NIV_DEBUG, NIV_MID_DEBUG or NIV_FULL_DEBUG expected.\n");
exit(1);
}
break;
case 'f':
/* config file */
strncpy(config_path, optarg, MAXPATHLEN);
break;
case 's':
/* single threaded */
single_threaded = TRUE;
break;
case 'd':
/* Detach or not detach ? */
detach_flag = TRUE;
break;
case 'R':
/* Shall we manage RPCSEC_GSS ? */
fprintf(stderr,
"\n\nThe -R flag is deprecated, use this syntax in the configuration file instead:\n\n");
fprintf(stderr, "NFS_KRB5\n");
fprintf(stderr, "{\n");
fprintf(stderr, "\tPrincipalName = nfs@<your_host> ;\n");
fprintf(stderr, "\tKeytabPath = /etc/krb5.keytab ;\n");
fprintf(stderr, "\tActive_krb5 = TRUE ;\n");
fprintf(stderr, "}\n\n\n");
exit(1);
break;
case 'F':
/* Flushes the data cache to the FSAL and purges the cache */
nfs_start_info.flush_datacache_mode = TRUE;
nfs_start_info.flush_behaviour = CACHE_CONTENT_FLUSH_AND_DELETE;
nfs_start_info.nb_flush_threads = (unsigned int)atoi(optarg);
if(nfs_start_info.nb_flush_threads > NB_MAX_FLUSHER_THREAD)
nfs_start_info.nb_flush_threads = NB_MAX_FLUSHER_THREAD;
break;
case 'S':
/* Flushes the data cache to the FSAL, without purging the cache */
nfs_start_info.flush_datacache_mode = TRUE;
nfs_start_info.flush_behaviour = CACHE_CONTENT_FLUSH_SYNC_ONLY;
nfs_start_info.nb_flush_threads = (unsigned int)atoi(optarg);
if(nfs_start_info.nb_flush_threads > NB_MAX_FLUSHER_THREAD)
nfs_start_info.nb_flush_threads = NB_MAX_FLUSHER_THREAD;
break;
case 'h':
/* display the help */
fprintf(stderr, usage, exec_name);
exit(0);
break;
case '?':
default:
/* ignore unsupported options */
fprintf(stderr, "WARNING: unknown GANESHA NFS daemon option: %c\n",
(char)optopt);
}
}
/* initialize memory and logging */
nfs_prereq_init(exec_name, host_name, debug_level, log_path);
/* Start in background, if wanted */
if(detach_flag)
{
/* Step 1: forking a service process */
switch (son_pid = fork())
{
case -1:
/* Fork failed */
LogError(COMPONENT_MAIN, ERR_SYS, ERR_FORK, errno);
LogCrit(COMPONENT_MAIN,
"Could nout start nfs daemon, exiting...");
exit(1);
case 0:
/* This code is within the son (that will actually work)
* Let's make it the leader of its group of process */
if(setsid() == -1)
{
LogError(COMPONENT_MAIN, ERR_SYS, ERR_SETSID, errno);
LogCrit(COMPONENT_MAIN,
"Could nout start nfs daemon, exiting...");
exit(1);
}
break;
default:
/* This code is within the father, it is useless, it must die */
LogFullDebug(COMPONENT_MAIN,
"Starting a son of pid %d\n", son_pid);
exit(0);
break;
}
}
/* Get the FSAL functions */
FSAL_LoadFunctions();
/* Get the FSAL consts */
FSAL_LoadConsts();
LogEvent(COMPONENT_MAIN,
">>>>>>>>>> Starting GANESHA NFS Daemon on FSAL/%s <<<<<<<<<<",
FSAL_GetFSName());
/* initialize default parameters */
nfs_set_param_default();
/* return all errors */
nfs_param.core_param.drop_io_errors = FALSE;
nfs_param.core_param.drop_inval_errors = FALSE;
nfs_param.core_param.drop_delay_errors = FALSE;
/* parse configuration file (if specified) */
if(strlen(config_path) > 0)
{
if(nfs_set_param_from_conf(&nfs_start_info))
{
LogCrit(COMPONENT_MAIN,
"NFS MAIN: Error parsing configuration file.");
exit(1);
}
}
/* set filesystem relative info */
((fusefs_specific_initinfo_t *) &nfs_param.fsal_param.fs_specific_info)->fs_ops = &ops;
((fusefs_specific_initinfo_t *) &nfs_param.fsal_param.fs_specific_info)->user_data = user_data;
#ifdef _SNMP_ADM_ACTIVE
if(!nfs_param.extern_param.snmp_adm.snmp_log_file[0])
strcpy(nfs_param.extern_param.snmp_adm.snmp_log_file, log_path);
#endif
/* add export by hand if no export was defined
* in config file (always '/')
*/
if(!nfs_param.pexportlist)
{
nfs_param.pexportlist = BuildDefaultExport();
if(nfs_param.pexportlist == NULL)
{
LogCrit(COMPONENT_MAIN,
"NFS MAIN: Could not create export entry for '/'");
exit(1);
}
}
/* if this is a single threaded application, set worker count */
if(single_threaded)
nfs_param.core_param.nb_worker = 1;
/* check parameters consitency */
if(nfs_check_param_consistency())
{
LogMajor(COMPONENT_MAIN,
"NFS MAIN: Inconsistent parameters found");
LogMajor(COMPONENT_MAIN,
"MAJOR WARNING: /!\\ | Bad Parameters could have significant impact on the daemon behavior");
exit(1);
}
/* Everything seems to be OK! We can now start service threads */
nfs_start(&nfs_start_info);
return 0;
}
/**
* @brief Read the configuration for the Cache inode layer
*
* @param[in] config Configuration file handle
* @param[out] param Read parameters
*
* @retval CACHE_INODE_SUCCESS on success.
* @retval CACHE_INODE_NOT_FOUND if stanza not present
* @retval CACHE_INODE_INVALID_ARGUMENT otherwise
*/
cache_inode_status_t
cache_inode_read_conf_parameter(config_file_t config,
cache_inode_parameter_t *param)
{
int var_max;
int var_index;
int err;
char *key_name;
char *key_value;
config_item_t block;
int DebugLevel = -1;
char *LogFile = NULL;
/* Is the config tree initialized ? */
if(config == NULL || param == NULL)
return CACHE_INODE_INVALID_ARGUMENT;
/* Get the config BLOCK */
if((block = config_FindItemByName(config,
CONF_LABEL_CACHE_INODE)) == NULL)
{
LogDebug(COMPONENT_CONFIG,
"Cannot read item \"%s\" from configuration file",
CONF_LABEL_CACHE_INODE);
return CACHE_INODE_NOT_FOUND;
}
else if(config_ItemType(block) != CONFIG_ITEM_BLOCK)
{
/* Expected to be a block */
LogCrit(COMPONENT_CONFIG,
"Item \"%s\" is expected to be a block",
CONF_LABEL_CACHE_INODE);
return CACHE_INODE_INVALID_ARGUMENT;
}
var_max = config_GetNbItems(block);
for(var_index = 0; var_index < var_max; var_index++)
{
config_item_t item;
item = config_GetItemByIndex(block, var_index);
/* Get key's name */
if((err = config_GetKeyValue(item, &key_name, &key_value)) != 0)
{
LogCrit(COMPONENT_CONFIG,
"Error reading key[%d] from section \"%s\" of configuration file.",
var_index, CONF_LABEL_CACHE_INODE);
return CACHE_INODE_INVALID_ARGUMENT;
}
else if(!strcasecmp(key_name, "Attr_Expiration_Time"))
{
err = parse_cache_expire(¶m->expire_type_attr,
¶m->grace_period_attr,
key_value);
if(err != CACHE_INODE_SUCCESS)
return err;
}
else if(!strcasecmp(key_name, "Symlink_Expiration_Time"))
{
err = parse_cache_expire(¶m->expire_type_link,
¶m->grace_period_link,
key_value);
if(err != CACHE_INODE_SUCCESS)
return err;
}
else if(!strcasecmp(key_name, "Directory_Expiration_Time"))
{
err = parse_cache_expire(¶m->expire_type_dirent,
¶m->grace_period_dirent,
key_value);
if(err != CACHE_INODE_SUCCESS)
return err;
}
else if(!strcasecmp(key_name, "Use_Getattr_Directory_Invalidation"))
{
param->getattr_dir_invalidation = StrToBoolean(key_value);
}
else if(!strcasecmp(key_name, "Use_Test_Access"))
{
param->use_test_access = atoi(key_value);
}
else if(!strcasecmp( key_name, "Use_FSAL_Hash" ) )
{
param->use_fsal_hash = StrToBoolean(key_value);
}
else if(!strcasecmp(key_name, "DebugLevel"))
{
DebugLevel = ReturnLevelAscii(key_value);
if(DebugLevel == -1)
{
LogDebug(COMPONENT_CACHE_INODE,
"cache_inode_read_conf: ERROR: Invalid debug level name: \"%s\".",
key_value);
return CACHE_INODE_INVALID_ARGUMENT;
}
}
else if(!strcasecmp(key_name, "LogFile"))
{
LogFile = key_value;
}
else
{
LogCrit(COMPONENT_CONFIG,
"Unknown or unsettable key: %s (item %s)",
key_name, CONF_LABEL_CACHE_INODE);
return CACHE_INODE_INVALID_ARGUMENT;
}
}
/* init logging */
if(LogFile)
SetComponentLogFile(COMPONENT_CACHE_INODE, LogFile);
if(DebugLevel > -1)
SetComponentLogLevel(COMPONENT_CACHE_INODE, DebugLevel);
return CACHE_INODE_SUCCESS;
} /* cache_inode_read_conf_parameter */