/*

  Copyright (c) 2012-2018 Red Hat, Inc. <http://www.redhat.com>

  This file is part of GlusterFS.

  This file is licensed to you under your choice of the GNU Lesser

  General Public License, version 3 or any later version (LGPLv3 or

  later), or the GNU General Public License, version 2 (GPLv2), in all

  cases as published by the Free Software Foundation.

*/

/*

  TODO:

  - set proper pid/lk_owner to call frames (currently buried in syncop)

  - fix logging.c/h to store logfp and loglevel in glusterfs_ctx_t and

    reach it via THIS.

  - update syncop functions to accept/return xdata. ???

  - protocol/client to reconnect immediately after portmap disconnect.

  - handle SEEK_END failure in _lseek()

  - handle umask (per filesystem?)

  - make itables LRU based

  - 0-copy for readv/writev

  - reconcile the open/creat mess

*/

#include <unistd.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <inttypes.h>

#include <sys/types.h>

#include <unistd.h>

#include <limits.h>

#ifdef GF_LINUX_HOST_OS

#include <sys/prctl.h>

#endif

#include <glusterfs/glusterfs.h>

#include <glusterfs/logging.h>

#include <glusterfs/stack.h>

#include <glusterfs/gf-event.h>

#include "glfs-mem-types.h"

#include <glusterfs/common-utils.h>

#include <glusterfs/syncop.h>

#include <glusterfs/call-stub.h>

#include <glusterfs/hashfn.h>

#include "rpc-clnt.h"

#include <glusterfs/statedump.h>

#include "gfapi-messages.h"

#include "glfs.h"

#include "glfs-internal.h"

static gf_boolean_t

vol_assigned(cmd_args_t *args)

{

    return args->volfile || args->volfile_server;

}

static int

glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx)

{

    call_pool_t *pool = NULL;

    int ret = -1;

    if (!ctx) {

        goto err;

    }

    ret = xlator_mem_acct_init(THIS, glfs_mt_end + 1);

    if (ret != 0) {

        gf_msg(THIS->name, GF_LOG_ERROR, ENOMEM, API_MSG_MEM_ACCT_INIT_FAILED,

               "Memory accounting init failed");

        return ret;

    }

    /* reset ret to -1 so that we don't need to explicitly

     * set it in all error paths before "goto err"

     */

    ret = -1;

    ctx->process_uuid = generate_glusterfs_ctx_id();

    if (!ctx->process_uuid) {

        goto err;

    }

    ctx->page_size = 128 * GF_UNIT_KB;

    ctx->iobuf_pool = iobuf_pool_new();

    if (!ctx->iobuf_pool) {

        goto err;

    }

    ctx->event_pool = event_pool_new(DEFAULT_EVENT_POOL_SIZE,

                                     STARTING_EVENT_THREADS);

    if (!ctx->event_pool) {

        goto err;

    }

    ctx->env = syncenv_new(0, 0, 0);

    if (!ctx->env) {

        goto err;

    }

    pool = GF_CALLOC(1, sizeof(call_pool_t), glfs_mt_call_pool_t);

    if (!pool) {

        goto err;

    }

    /* frame_mem_pool size 112 * 4k */

    pool->frame_mem_pool = mem_pool_new(call_frame_t, 4096);

    if (!pool->frame_mem_pool) {

        goto err;

    }

    /* stack_mem_pool size 256 * 1024 */

    pool->stack_mem_pool = mem_pool_new(call_stack_t, 1024);

    if (!pool->stack_mem_pool) {

        goto err;

    }

    ctx->stub_mem_pool = mem_pool_new(call_stub_t, 1024);

    if (!ctx->stub_mem_pool) {

        goto err;

    }

    ctx->dict_pool = mem_pool_new(dict_t, GF_MEMPOOL_COUNT_OF_DICT_T);

    if (!ctx->dict_pool)

        goto err;

    ctx->dict_pair_pool = mem_pool_new(data_pair_t,

                                       GF_MEMPOOL_COUNT_OF_DATA_PAIR_T);

    if (!ctx->dict_pair_pool)

        goto err;

    ctx->dict_data_pool = mem_pool_new(data_t, GF_MEMPOOL_COUNT_OF_DATA_T);

    if (!ctx->dict_data_pool)

        goto err;

    ctx->logbuf_pool = mem_pool_new(log_buf_t, GF_MEMPOOL_COUNT_OF_LRU_BUF_T);

    if (!ctx->logbuf_pool)

        goto err;

    INIT_LIST_HEAD(&pool->all_frames);

    INIT_LIST_HEAD(&ctx->cmd_args.xlator_options);

    INIT_LIST_HEAD(&ctx->cmd_args.volfile_servers);

    LOCK_INIT(&pool->lock);

    ctx->pool = pool;

    ret = 0;

err:

    if (ret && pool) {

        if (pool->frame_mem_pool)

            mem_pool_destroy(pool->frame_mem_pool);

        if (pool->stack_mem_pool)

            mem_pool_destroy(pool->stack_mem_pool);

        GF_FREE(pool);

    }

    if (ret && ctx) {

        if (ctx->stub_mem_pool)

            mem_pool_destroy(ctx->stub_mem_pool);

        if (ctx->dict_pool)

            mem_pool_destroy(ctx->dict_pool);

        if (ctx->dict_data_pool)

            mem_pool_destroy(ctx->dict_data_pool);

        if (ctx->dict_pair_pool)

            mem_pool_destroy(ctx->dict_pair_pool);

        if (ctx->logbuf_pool)

            mem_pool_destroy(ctx->logbuf_pool);

    }

    return ret;

}

static int

create_master(struct glfs *fs)

{

    int ret = 0;

    xlator_t *master = NULL;

    master = GF_CALLOC(1, sizeof(*master), glfs_mt_xlator_t);

    if (!master)

        goto err;

    master->name = gf_strdup("gfapi");

    if (!master->name)

        goto err;

    if (xlator_set_type(master, "mount/api") == -1) {

        gf_msg("glfs", GF_LOG_ERROR, 0, API_MSG_MASTER_XLATOR_INIT_FAILED,

               "master xlator "

               "for %s initialization failed",

               fs->volname);

        goto err;

    }

    master->ctx = fs->ctx;

    master->private = fs;

    master->options = dict_new();

    if (!master->options)

        goto err;

    ret = xlator_init(master);

    if (ret) {

        gf_msg("glfs", GF_LOG_ERROR, 0, API_MSG_GFAPI_XLATOR_INIT_FAILED,

               "failed to initialize gfapi translator");

        goto err;

    }

    fs->ctx->master = master;

    THIS = master;

    return 0;

err:

    if (master) {

        xlator_destroy(master);

    }

    return -1;

}

static FILE *

get_volfp(struct glfs *fs)

{

    cmd_args_t *cmd_args = NULL;

    FILE *specfp = NULL;

    cmd_args = &fs->ctx->cmd_args;

    if ((specfp = fopen(cmd_args->volfile, "r")) == NULL) {

        gf_msg("glfs", GF_LOG_ERROR, errno, API_MSG_VOLFILE_OPEN_FAILED,

               "volume file %s open failed: %s", cmd_args->volfile,

               strerror(errno));

        return NULL;

    }

    gf_msg_debug("glfs", 0, "loading volume file %s", cmd_args->volfile);

    return specfp;

}

int

glfs_volumes_init(struct glfs *fs)

{

    FILE *fp = NULL;

    cmd_args_t *cmd_args = NULL;

    int ret = 0;

    cmd_args = &fs->ctx->cmd_args;

    if (!vol_assigned(cmd_args))

        return -1;

    if (cmd_args->volfile_server) {

        ret = glfs_mgmt_init(fs);

        goto out;

    }

    fp = get_volfp(fs);

    if (!fp) {

        gf_msg("glfs", GF_LOG_ERROR, ENOENT, API_MSG_VOL_SPEC_FILE_ERROR,

               "Cannot reach volume specification file");

        ret = -1;

        goto out;

    }

    ret = glfs_process_volfp(fs, fp);

    if (ret)

        goto out;

out:

    return ret;

}

///////////////////////////////////////////////////////////////////////////////

int

pub_glfs_set_xlator_option(struct glfs *fs, const char *xlator, const char *key,

                           const char *value)

{

    xlator_cmdline_option_t *option = NULL;

    DECLARE_OLD_THIS;

    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);

    option = GF_CALLOC(1, sizeof(*option), glfs_mt_xlator_cmdline_option_t);

    if (!option)

        goto enomem;

    INIT_LIST_HEAD(&option->cmd_args);

    option->volume = gf_strdup(xlator);

    if (!option->volume)

        goto enomem;

    option->key = gf_strdup(key);

    if (!option->key)

        goto enomem;

    option->value = gf_strdup(value);

    if (!option->value)

        goto enomem;

    list_add(&option->cmd_args, &fs->ctx->cmd_args.xlator_options);

    __GLFS_EXIT_FS;

    return 0;

enomem:

    errno = ENOMEM;

    if (!option) {

        __GLFS_EXIT_FS;

        return -1;

    }

    GF_FREE(option->volume);

    GF_FREE(option->key);

    GF_FREE(option->value);

    GF_FREE(option);

    __GLFS_EXIT_FS;

invalid_fs:

    return -1;

}

GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_xlator_option, 3.4.0);

int

pub_glfs_unset_volfile_server(struct glfs *fs, const char *transport,

                              const char *host, const int port)

{

    cmd_args_t *cmd_args = NULL;

    server_cmdline_t *server = NULL;

    server_cmdline_t *tmp = NULL;

    char *transport_val = NULL;

    int port_val = 0;

    int ret = -1;

    if (!fs || !host) {

        errno = EINVAL;

        return ret;

    }

    DECLARE_OLD_THIS;

    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);

    cmd_args = &fs->ctx->cmd_args;

    if (transport) {

        transport_val = gf_strdup(transport);

    } else {

        transport_val = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT);

    }

    if (!transport_val) {

        errno = ENOMEM;

        goto out;

    }

    if (port) {

        port_val = port;

    } else {

        port_val = GF_DEFAULT_BASE_PORT;

    }

    list_for_each_entry_safe(server, tmp, &cmd_args->curr_server->list, list)

    {

        if ((!strcmp(server->volfile_server, host) &&

             !strcmp(server->transport, transport_val) &&

             (server->port == port_val))) {

            list_del(&server->list);

            ret = 0;

            goto out;

        }

    }

out:

    GF_FREE(transport_val);

    __GLFS_EXIT_FS;

invalid_fs:

    return ret;

}

GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_unset_volfile_server, 3.5.1);

int

pub_glfs_set_volfile_server(struct glfs *fs, const char *transport,

                            const char *host, int port)

{

    cmd_args_t *cmd_args = NULL;

    int ret = -1;

    char *server_host = NULL;

    char *server_transport = NULL;

    if (!fs || !host) {

        errno = EINVAL;

        return ret;

    }

    DECLARE_OLD_THIS;

    __GLFS_ENTRY_VALIDATE_FS(fs, invalid_fs);

    cmd_args = &fs->ctx->cmd_args;

    cmd_args->max_connect_attempts = 1;

    server_host = gf_strdup(host);

    if (!server_host) {

        errno = ENOMEM;

        goto out;

    }

    if (transport) {

        /* volfile fetch support over tcp|unix only */

        if (!strcmp(transport, "tcp") || !strcmp(transport, "unix")) {

            server_transport = gf_strdup(transport);

        } else if (!strcmp(transport, "rdma")) {

            server_transport = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT);

            gf_msg("glfs", GF_LOG_WARNING, EINVAL, API_MSG_INVALID_ENTRY,

                   "transport RDMA is deprecated, "

                   "falling back to tcp");

        } else {

            gf_msg("glfs", GF_LOG_TRACE, EINVAL, API_MSG_INVALID_ENTRY,

                   "transport %s is not supported, "

                   "possible values tcp|unix",

                   transport);

            goto out;

        }

    } else {

        server_transport = gf_strdup(GF_DEFAULT_VOLFILE_TRANSPORT);

    }

    if (!server_transport) {

        errno = ENOMEM;

        goto out;

    }

    if (!port) {

        port = GF_DEFAULT_BASE_PORT;

    }

    if (!strcmp(server_transport, "unix")) {

        port = 0;

    }

    ret = gf_set_volfile_server_common(cmd_args, server_host, server_transport,

                                       port);

    if (ret) {

        gf_log("glfs", GF_LOG_ERROR, "failed to set volfile server: %s",

               strerror(errno));

    }

out:

    if (server_host) {

        GF_FREE(server_host);

    }

    if (server_transport) {

        GF_FREE(server_transport);

    }

    __GLFS_EXIT_FS;

invalid_fs:

    return ret;

}

GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_set_volfile_server, 3.4.0);

/* *

 * Used to free the arguments allocated by glfs_set_volfile_server()

 */

static void

glfs_free_volfile_servers(cmd_args_t *cmd_args)

{

    server_cmdline_t *server = NULL;

    server_cmdline_t *tmp = NULL;

    GF_VALIDATE_OR_GOTO(THIS->name, cmd_args, out);

    list_for_each_entry_safe(server, tmp, &cmd_args->volfile_servers, list)

    {

        list_del_init(&server->list);

        GF_FREE(server->volfile_server);

        GF_FREE(server->transport);

        GF_FREE(server);

    }

    cmd_args->curr_server = NULL;

out:

    return;

}

static void

glfs_free_xlator_options(cmd_args_t *cmd_args)

{

    xlator_cmdline_option_t *xo = NULL;

    xlator_cmdline_option_t *tmp_xo = NULL;

    if (!&(cmd_args->xlator_options))

        return;

    list_for_each_entry_safe(xo, tmp_xo, &cmd_args->xlator_options, cmd_args)

    {

        list_del_init(&xo->cmd_args);

        GF_FREE(xo->volume);

        GF_FREE(xo->key);

        GF_FREE(xo->value);

        GF_FREE(xo);

    }

}

int

pub_glfs_setfsuid(uid_t fsuid)

{

    /* TODO:

     * - Set the THIS and restore it appropriately

     */

    return syncopctx_setfsuid(&fsuid);

}

GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsuid, 3.4.2);

int

pub_glfs_setfsgid(gid_t fsgid)

{

    /* TODO:

     * - Set the THIS and restore it appropriately

     */

    return syncopctx_setfsgid(&fsgid);

}

GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgid, 3.4.2);

int

pub_glfs_setfsgroups(size_t size, const gid_t *list)

{

    /* TODO:

     * - Set the THIS and restore it appropriately

     */

    return syncopctx_setfsgroups(size, list);

}

GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsgroups, 3.4.2);

int

pub_glfs_setfsleaseid(glfs_leaseid_t leaseid)

{

    int ret = -1;

    char *gleaseid = NULL;

    gleaseid = gf_leaseid_get();

    if (gleaseid) {

        if (leaseid)

            memcpy(gleaseid, leaseid, LEASE_ID_SIZE);

        else /* reset leaseid */

            memset(gleaseid, 0, LEASE_ID_SIZE);

        ret = 0;

    }

    if (ret)

        gf_log("glfs", GF_LOG_ERROR, "failed to set leaseid: %s",

               strerror(errno));

    return ret;

}

GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_setfsleaseid, 4.0.0);

int

get_fop_attr_glfd(dict_t **fop_attr, struct glfs_fd *glfd)

{

    char *leaseid = NULL;

    int ret = 0;

    gf_boolean_t dict_create = _gf_false;

    leaseid = GF_MALLOC(LEASE_ID_SIZE, gf_common_mt_char);

    GF_CHECK_ALLOC_AND_LOG("gfapi", leaseid, ret, "lease id alloc failed", out);

    memcpy(leaseid, glfd->lease_id, LEASE_ID_SIZE);

    if (*fop_attr == NULL) {

        *fop_attr = dict_new();

        dict_create = _gf_true;

    }

    GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out);

    ret = dict_set_bin(*fop_attr, "lease-id", leaseid, LEASE_ID_SIZE);

out:

    if (ret) {

        GF_FREE(leaseid);

        if (dict_create) {

            if (*fop_attr)

                dict_unref(*fop_attr);

            *fop_attr = NULL;

        }

    }

    return ret;

}

int

set_fop_attr_glfd(struct glfs_fd *glfd)

{

    char *lease_id = NULL;

    int ret = -1;

    lease_id = gf_existing_leaseid();

    if (lease_id) {

        memcpy(glfd->lease_id, lease_id, LEASE_ID_SIZE);

        ret = 0;

    }

    return ret;

}

int

get_fop_attr_thrd_key(dict_t **fop_attr)

{

    char *existing_leaseid = NULL, *leaseid = NULL;

    int ret = 0;

    gf_boolean_t dict_create = _gf_false;

    existing_leaseid = gf_existing_leaseid();

    if (existing_leaseid) {

        leaseid = GF_MALLOC(LEASE_ID_SIZE, gf_common_mt_char);

        GF_CHECK_ALLOC_AND_LOG("gfapi", leaseid, ret, "lease id alloc failed",

                               out);

        memcpy(leaseid, existing_leaseid, LEASE_ID_SIZE);

        if (*fop_attr == NULL) {

            *fop_attr = dict_new();

            dict_create = _gf_true;

        }

        GF_CHECK_ALLOC_AND_LOG("gfapi", *fop_attr, ret, "dict_new failed", out);

        ret = dict_set_bin(*fop_attr, "lease-id", leaseid, LEASE_ID_SIZE);

    }

out:

    if (ret) {

        GF_FREE(leaseid);

        if (dict_create) {

            if (*fop_attr)

                dict_unref(*fop_attr);

            *fop_attr = NULL;

        }

    }

    return ret;

}

void

unset_fop_attr(dict_t **fop_attr)

{

    char *lease_id = NULL;

    lease_id = gf_existing_leaseid();

    if (lease_id)

        memset(lease_id, 0, LEASE_ID_SIZE);

    if (*fop_attr) {

        dict_unref(*fop_attr);

        *fop_attr = NULL;

    }

}

struct glfs *

pub_glfs_from_glfd(struct glfs_fd *glfd)

{

    return glfd->fs;

}

GFAPI_SYMVER_PUBLIC_DEFAULT(glfs_from_glfd, 3.4.0);

static void

glfs_fd_destroy(struct glfs_fd *glfd)

{

    if (!glfd)

        return;

    glfs_lock(glfd->fs, _gf_true);

    {

        list_del_init(&glfd->openfds);

    }

    glfs_unlock(glfd->fs);

    if (glfd->fd) {

        fd_unref(glfd->fd);

        glfd->fd = NULL;

    }

    GF_FREE(glfd->readdirbuf);

    GF_FREE(glfd);

}

struct glfs_fd *

glfs_fd_new(struct glfs *fs)

{

    struct glfs_fd *glfd = NULL;

    glfd = GF_CALLOC(1, sizeof(*glfd), glfs_mt_glfs_fd_t);

    if (!glfd)

        return NULL;

    glfd->fs = fs;

    INIT_LIST_HEAD(&glfd->openfds);

    GF_REF_INIT(glfd, glfs_fd_destroy);

    return glfd;

}

void

glfs_fd_bind(struct glfs_fd *glfd)

{

    struct glfs *fs = NULL;

    fs = glfd->fs;

    glfs_lock(fs, _gf_true);

    {

        list_add_tail(&glfd->openfds, &fs->openfds);

    }

    glfs_unlock(fs);

}

static void *

glfs_poller(void *data)

{

    struct glfs *fs = NULL;

    fs = data;

    event_dispatch(fs->ctx->event_pool);

    return NULL;

}

static struct glfs *

glfs_new_fs(const char *volname)

{

    struct glfs *fs = NULL;

    fs = CALLOC(1, sizeof(*fs));

    if (!fs)

        return NULL;

    INIT_LIST_HEAD(&fs->openfds);

    INIT_LIST_HEAD(&fs->upcall_list);

    PTHREAD_MUTEX_INIT(&fs->mutex, NULL, fs->pthread_flags, GLFS_INIT_MUTEX,

                       err);

    PTHREAD_COND_INIT(&fs->cond, NULL, fs->pthread_flags, GLFS_INIT_COND, err);

    PTHREAD_COND_INIT(&fs->child_down_cond, NULL, fs->pthread_flags,

                      GLFS_INIT_COND_CHILD, err);

    PTHREAD_MUTEX_INIT(&fs->upcall_list_mutex, NULL, fs->pthread_flags,

                       GLFS_INIT_MUTEX_UPCALL, err);

    fs->volname = strdup(volname);

    if (!fs->volname)

        goto err;

    fs->pin_refcnt = 0;

    fs->upcall_events = 0;

    fs->up_cbk = NULL;

    fs->up_data = NULL;

    return fs;

err:

    glfs_free_from_ctx(fs);

    return NULL;

}

extern xlator_t global_xlator;

extern glusterfs_ctx_t *global_ctx;

extern pthread_mutex_t global_ctx_mutex;

static int

glfs_init_global_ctx()

{

    int ret = 0;

    glusterfs_ctx_t *ctx = NULL;

    pthread_mutex_lock(&global_ctx_mutex);

    {

        if (global_xlator.ctx)

            goto unlock;

        ctx = glusterfs_ctx_new();

        if (!ctx) {

            ret = -1;

            goto unlock;

        }

        gf_log_globals_init(ctx, GF_LOG_NONE);

        global_ctx = ctx;

        global_xlator.ctx = global_ctx;

        ret = glusterfs_ctx_defaults_init(ctx);

        if (ret) {

            global_ctx = NULL;

            global_xlator.ctx = NULL;

            goto unlock;

        }

    }

unlock:

    pthread_mutex_unlock(&global_ctx_mutex);

    if (ret)

        FREE(ctx);

    return ret;

}

struct glfs *

pub_glfs_new(const char *volname)

{

    struct glfs *fs = NULL;

    int ret = -1;

    glusterfs_ctx_t *ctx = NULL;

    xlator_t *old_THIS = NULL;

    char pname[16] = "";

    char msg[32] = "";

    if (!volname) {

        errno = EINVAL;

        return NULL;

    }

    /*

     * Do this as soon as possible in case something else depends on

     * pool allocations.

     */

    mem_pools_init_early();

    mem_pools_init_late();

    fs = glfs_new_fs(volname);

    if (!fs)

        goto out;

    ctx = glusterfs_ctx_new();

    if (!ctx)

        goto out;

    /* first globals init, for gf_mem_acct_enable_set () */

    ret = glusterfs_globals_init(ctx);

    if (ret)

        goto out;

    old_THIS = THIS;

    ret = glfs_init_global_ctx();

    if (ret)

        goto out;

    /* then ctx_defaults_init, for xlator_mem_acct_init(THIS) */

    ret = glusterfs_ctx_defaults_init(ctx);

    if (ret)

        goto out;

    fs->ctx = ctx;

    fs->ctx->process_mode = GF_CLIENT_PROCESS;

    ret = glfs_set_logging(fs, "/dev/null", 0);

    if (ret)

        goto out;

    fs->ctx->cmd_args.volfile_id = gf_strdup(volname);

    if (!(fs->ctx->cmd_args.volfile_id)) {

        ret = -1;

        goto out;

    }

    ret = -1;

#ifdef GF_LINUX_HOST_OS

    ret = prctl(PR_GET_NAME, (unsigned long)pname, 0, 0, 0);

#endif

    if (ret)

        fs->ctx->cmd_args.process_name = gf_strdup("gfapi");

    else {

        snprintf(msg, sizeof(msg), "gfapi.%s", pname);