gfarm_error_t
gfs_statfs(gfarm_off_t *used, gfarm_off_t *avail, gfarm_off_t *files)
{
gfarm_error_t e;
struct gfm_connection *gfm_server;
int retry = 0;
for (;;) {
if ((e = gfm_client_connection_and_process_acquire(
gfarm_metadb_server_name, gfarm_metadb_server_port,
&gfm_server)) != GFARM_ERR_NO_ERROR)
return (e);
e = gfm_client_statfs(gfm_server, used, avail, files);
if (gfm_client_is_connection_error(e) && ++retry <= 1){
gfm_client_connection_free(gfm_server);
continue;
}
break;
}
gfm_client_connection_free(gfm_server);
return (e);
}
static gfarm_error_t
acquire_valid_connection(struct gfm_connection *gfm_server, const char *host,
int port, const char *user, struct gfarm_filesystem *fs)
{
gfarm_error_t e;
int fc = gfarm_filesystem_failover_count(fs);
int acquired = 0;
while (fc > gfm_client_connection_failover_count(gfm_server)) {
gfm_client_purge_from_cache(gfm_server);
if (acquired)
gfm_client_connection_free(gfm_server);
if ((e = gfm_client_connection_and_process_acquire(
host, port, user, &gfm_server)) != GFARM_ERR_NO_ERROR) {
gflog_debug(GFARM_MSG_1003860,
"gfm_client_connection_and_process_acquire: %s",
gfarm_error_string(e));
return (e);
}
acquired = 1;
}
if (acquired)
gfm_client_connection_free(gfm_server);
gfarm_filesystem_set_failover_detected(fs, 0);
return (GFARM_ERR_NO_ERROR);
}
gfarm_error_t
gfs_statfsnode(char *host, int port,
gfarm_int32_t *bsize, gfarm_off_t *blocks, gfarm_off_t *bfree,
gfarm_off_t *bavail, gfarm_off_t *files, gfarm_off_t *ffree,
gfarm_off_t *favail)
{
gfarm_error_t e;
struct gfm_connection *gfm_server;
struct gfs_connection *gfs_server;
int retry = 0;
for (;;) {
if ((e = gfm_client_connection_and_process_acquire(
gfarm_metadb_server_name, gfarm_metadb_server_port,
&gfm_server)) != GFARM_ERR_NO_ERROR)
return (e);
if ((e = gfs_client_connection_acquire_by_host(gfm_server,
host, port, &gfs_server, NULL))!= GFARM_ERR_NO_ERROR)
goto free_gfm_connection;
if (gfs_client_pid(gfs_server) == 0)
e = gfarm_client_process_set(gfs_server, gfm_server);
if (e == GFARM_ERR_NO_ERROR) {
/* "/" is actually not used */
e = gfs_client_statfs(gfs_server, "/", bsize, blocks,
bfree, bavail, files, ffree, favail);
if (gfs_client_is_connection_error(e) && ++retry<=1) {
gfs_client_connection_free(gfs_server);
continue;
}
}
break;
}
gfs_client_connection_free(gfs_server);
free_gfm_connection:
gfm_client_connection_free(gfm_server);
return (e);
}
static gfarm_error_t
failover0(struct gfm_connection *gfm_server, const char *host0, int port,
const char *user0)
{
gfarm_error_t e;
struct gfarm_filesystem *fs;
struct gfs_file_list *gfl = NULL;
char *host = NULL, *user = NULL;
int fc, i, ok = 0;
if (gfm_server) {
fs = gfarm_filesystem_get_by_connection(gfm_server);
if (gfarm_filesystem_in_failover_process(fs)) {
e = GFARM_ERR_OPERATION_NOT_PERMITTED;
gflog_debug(GFARM_MSG_1003861,
"gfmd connection failover process called "
"recursively");
goto error_all;
}
gfarm_filesystem_set_in_failover_process(fs, 1);
fc = gfarm_filesystem_failover_count(fs);
if ((host = strdup(gfm_client_hostname(gfm_server))) == NULL) {
e = GFARM_ERR_NO_MEMORY;
gflog_debug(GFARM_MSG_1003388,
"%s", gfarm_error_string(e));
goto error_all;
}
if ((user = strdup(gfm_client_username(gfm_server))) == NULL) {
e = GFARM_ERR_NO_MEMORY;
gflog_debug(GFARM_MSG_1003389,
"%s", gfarm_error_string(e));
goto error_all;
}
port = gfm_client_port(gfm_server);
if (fc > gfm_client_connection_failover_count(gfm_server)) {
/* already failover occurred */
e = acquire_valid_connection(gfm_server, host, port,
user, fs);
goto end;
}
} else {
fs = gfarm_filesystem_get(host0, port);
assert(fs != NULL);
if (gfarm_filesystem_in_failover_process(fs)) {
e = GFARM_ERR_OPERATION_NOT_PERMITTED;
gflog_debug(GFARM_MSG_1003862,
"gfmd connection failover process called "
"recursively");
goto error_all;
}
gfarm_filesystem_set_in_failover_process(fs, 1);
fc = gfarm_filesystem_failover_count(fs);
if ((host = strdup(host0)) == NULL) {
e = GFARM_ERR_NO_MEMORY;
gflog_debug(GFARM_MSG_1003863,
"%s", gfarm_error_string(e));
goto error_all;
}
if ((user = strdup(user0)) == NULL) {
e = GFARM_ERR_NO_MEMORY;
gflog_debug(GFARM_MSG_1003864,
"%s", gfarm_error_string(e));
goto error_all;
}
}
gfl = gfarm_filesystem_opened_file_list(fs);
/*
* failover_count must be incremented before acquire connection
* because failover_count is set at creating new connection
* and we use failover_count to indicate whether or not the acquired
* connection is new connection.
*/
gfarm_filesystem_set_failover_count(fs, fc + 1);
for (i = 0; i < NUM_FAILOVER_RETRY; ++i) {
/* reconnect to gfmd */
if ((e = gfm_client_connection_and_process_acquire(
host, port, user, &gfm_server)) != GFARM_ERR_NO_ERROR) {
gflog_debug(GFARM_MSG_1003390,
"gfm_client_connection_acquire failed : %s",
gfarm_error_string(e));
continue;
}
if (gfm_client_connection_failover_count(gfm_server)
!= fc + 1) {
/*
* When this function is called from
* gfm_client_connection_failover_pre_connect(),
* the acquired connection is possibly an old
* connection.
*/
gfm_client_purge_from_cache(gfm_server);
gfm_client_connection_free(gfm_server);
--i;
continue;
}
/*
* close fd, release gfm_connection and set invalid fd,
* reset processes and reopen files
*/
ok = reset_and_reopen_all(gfm_server, gfl);
gfm_client_connection_free(gfm_server);
if (ok)
break;
}
if (ok) {
gfarm_filesystem_set_failover_detected(fs, 0);
e = GFARM_ERR_NO_ERROR;
gflog_notice(GFARM_MSG_1003391,
"connection to metadb server was failed over successfully");
} else {
gfarm_filesystem_set_failover_detected(fs, 1);
e = GFARM_ERR_OPERATION_TIMED_OUT;
gflog_debug(GFARM_MSG_1003392,
"falied to fail over: %s", gfarm_error_string(e));
}
end:
free(host);
free(user);
gfarm_filesystem_set_in_failover_process(fs, 0);
return (e);
error_all:
free(host);
free(user);
if (gfl != NULL)
gfs_pio_file_list_foreach(gfl, set_error, &e);
gfarm_filesystem_set_in_failover_process(fs, 0);
return (e);
}
