glusterfs
2974 строки · 90.3 Кб
1/*2Copyright (c) 2006-2016 Red Hat, Inc. <http://www.redhat.com>3This file is part of GlusterFS.4This file is licensed to you under your choice of the GNU Lesser6General Public License, version 3 or any later version (LGPLv3 or7later), or the GNU General Public License, version 2 (GPLv2), in all8cases as published by the Free Software Foundation.9*/10#include <stdio.h>11#include <string.h>12#include <stdlib.h>13#include <sys/wait.h>14#include <dlfcn.h>15#include <pthread.h>16#include <errno.h>17#include <pwd.h>18/* using argp for command line parsing */58static char gf_doc[] = "";59static char argp_doc[] =60"--volfile-server=SERVER [MOUNT-POINT]\n"61"--volfile=VOLFILE [MOUNT-POINT]";62const char *argp_program_version =63"" PACKAGE_NAME " " PACKAGE_VERSION64"\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION65"\n"66"Copyright (c) 2006-2016 Red Hat, Inc. "67"<https://www.gluster.org/>\n"68"GlusterFS comes with ABSOLUTELY NO WARRANTY.\n"69"It is licensed to you under your choice of the GNU Lesser\n"70"General Public License, version 3 or any later version (LGPLv3\n"71"or later), or the GNU General Public License, version 2 (GPLv2),\n"72"in all cases as published by the Free Software Foundation.";73const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";74{284cmd_args_t *cmd_args = NULL;285}302{312int ret = 0;313cmd_args_t *cmd_args = NULL;314char *mount_point = NULL;315char cwd[PATH_MAX] = {3160,317};318* if not convert to absolute path by concatenating with CWD323*/324if (cmd_args->mount_point[0] != '/') {325if (getcwd(cwd, PATH_MAX) != NULL) {326ret = gf_asprintf(&mount_point, "%s/%s", cwd,327cmd_args->mount_point);328if (ret == -1) {329gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_1,330"gf_asprintf failed", NULL);331goto err;332}333} else {334gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_2,335"getcwd failed", NULL);336goto err;337}338}609{613int ret = 0;614cmd_args_t *cmd_args = NULL;615xlator_t *root = NULL;616}679{683glusterfs_ctx_t *ctx = NULL;684cmd_args_t *cmd_args = NULL;685int ret = -1;686}704{708glusterfs_ctx_t *ctx = NULL;709cmd_args_t *cmd_args = NULL;710xlator_cmdline_option_t *option = NULL;711int ret = -1;712char *dot = NULL;713char *equals = NULL;714}774{788struct oom_api_info *api = NULL;789}798#endif799{803cmd_args_t *cmd_args = NULL;804uint32_t n = 0;805#ifdef GF_LINUX_HOST_OS806int32_t k = 0;807struct oom_api_info *api = NULL;808#endif809double d = 0.0;810gf_boolean_t b = _gf_false;811char *tmp_str = NULL;812char *port_str = NULL;813struct passwd *pw = NULL;814int ret = 0;815}1469void1471cleanup_and_exit(int signum)1472{1473glusterfs_ctx_t *ctx = NULL;1474xlator_t *trav = NULL;1475xlator_t *top;1476xlator_t *victim;1477xlator_list_t **trav_p;1478* signal handler - gf_print_trace() - is the big question here.1486*1487* Taking mutex in signal handler would mean that if the process1488* receives a fatal signal while another thread is holding1489* ctx->log.log_buf_lock to perhaps log a message in _gf_msg_internal(),1490* the offending thread hangs on the mutex lock forever without letting1491* the process exit.1492*1493* On the other hand. not taking the mutex in signal handler would cause1494* it to modify the lru_list of buffered log messages in a racy manner,1495* corrupt the list and potentially give rise to an unending1496* cascade of SIGSEGVs and other re-entrancy issues.1497*/1498* and multiple brick instances are attached to this process1512*/1513if (ctx->active) {1514top = ctx->active->first;1515for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) {1516victim = (*trav_p)->xlator;1517rpc_clnt_mgmt_pmap_signout(ctx, victim->name);1518}1519} else {1520rpc_clnt_mgmt_pmap_signout(ctx, NULL);1521}1522* But in another thread (epoll thread), upon poll error in the1525* socket the transports are cleaned up where again rpcsvc object1526* is accessed (which is already freed by the below function).1527* Since the process is about to be killed don't execute the function1528* below.1529*/1530/* if (ctx->listener) { */1531/* (void) glusterfs_listener_stop (ctx); */1532/* } */1533* so there are no more requests coming and1536* 'umount' of mount point is done properly */1537trav = ctx->root;1538if (trav && trav->fini) {1539THIS = trav;1540trav->fini(trav);1541}1542process exit. As we are releasing the cleanup mutex lock, before1558the process can exit some other thread which is blocked on1559cleanup mutex lock is acquiring the cleanup mutex lock and1560trying to acquire some resources which are already freed as a1561part of cleanup. To avoid this, we are exiting the process without1562releasing the cleanup mutex lock. This will not cause any lock1563related issues as the process which acquired the lock is going down1564*/1565/* NOTE: Only the least significant 8 bits i.e (signum & 255)1566will be available to parent process on calling exit() */1567exit(abs(signum));1568}1569}1570{1574cmd_args_t *cmd_args = NULL;1575FILE *specfp = NULL;1576}1589{1593int ret = -1;1594char *volfile = NULL;1595gf_volfile_t *volfile_obj = NULL;1596gf_volfile_t *volfile_tmp = NULL;1597struct stat stbuf = {15980,1599};1600char sha256_hash[SHA256_DIGEST_LENGTH] = {16010,1602};1603* volfile if topology hasn't changed.1651* glusterfs_volfile_reconfigure returns 3 possible return states1652* return 0 =======> reconfiguration of options has succeeded1653* return 1 =======> the graph has to be reconstructed and all1654* the xlators should be inited return -1(or -ve) =======> Some Internal1655* Error occurred during the operation1656*/1657}1710{1714int ret = 0;1715glusterfs_ctx_t *ctx = NULL;1716cmd_args_t *cmd_args = NULL;1717}1742void1744emancipate(glusterfs_ctx_t *ctx, int ret)1745{1746/* break free from the parent */1747if (ctx->daemon_pipe[1] != -1) {1748sys_write(ctx->daemon_pipe[1], (void *)&ret, sizeof(ret));1749sys_close(ctx->daemon_pipe[1]);1750ctx->daemon_pipe[1] = -1;1751}1752}1753{1757char *dup_execname = NULL, *base = NULL;1758uint8_t ret = 0;1759}1775{1779cmd_args_t *cmd_args = NULL;1780struct rlimit lim = {17810,1782};1783int ret = -1;1784* set it in all error paths before "goto err"1796*/1797ret = -1;1798* which may corrupt the data1878*/1879cmd_args->fuse_direct_io_mode = GF_OPTION_DISABLE;1880#else1881cmd_args->fuse_direct_io_mode = GF_OPTION_DEFERRED;1882#endif1883cmd_args->fuse_attribute_timeout = -1;1884cmd_args->fuse_entry_timeout = -1;1885cmd_args->fopen_keep_cache = GF_OPTION_DEFERRED;1886cmd_args->kernel_writeback_cache = GF_OPTION_DEFERRED;1887cmd_args->fuse_flush_handle_interrupt = GF_OPTION_DEFERRED;1888cmd_args->fuse_setlk_handle_interrupt = GF_OPTION_DEFERRED;1889}1924{1928int ret = 0;1929char *ptr = NULL;1930* seems ugly and can be bettered? */1938/* just get the filename as the ident */1939if (NULL != (ptr = strrchr(cmd_args->log_file, '/'))) {1940ret = gf_asprintf(&cmd_args->log_ident, "%s", ptr + 1);1941} else {1942ret = gf_asprintf(&cmd_args->log_ident, "%s", cmd_args->log_file);1943}1944}1959{1963cmd_args_t *cmd_args = NULL;1964int ret = 0;1965* except for the log flush timer, which will be injected post fork(2)2009* in daemonize() . During this time, any log message that is logged2010* will be kept buffered. And if the list that holds these messages2011* overflows, then the same lru policy is used to drive out the least2012* recently used message and displace it with the message just logged.2013*/2014}2017{2021int i = 0;2022}2030#ifdef BUILD_GNFS2031/**2032* print_exports_file - Print out & verify the syntax2033* of the exports file specified2034* in the parameter.2035*2036* @exports_file : Path of the exports file to print & verify2037*2038* @return : success: 0 when successfully parsed2039* failure: 1 when failed to parse one or more lines2040* -1 when other critical errors (dlopen () etc)2041* Critical errors are treated differently than parse errors. Critical2042* errors terminate the program immediately here and print out different2043* error messages. Hence there are different return values.2044*/2045static int2046print_exports_file(const char *exports_file)2047{2048void *libhandle = NULL;2049char *libpathfull = NULL;2050struct exports_file *file = NULL;2051int ret = 0;2052}2124/**2126* print_netgroups_file - Print out & verify the syntax2127* of the netgroups file specified2128* in the parameter.2129*2130* @netgroups_file : Path of the netgroups file to print & verify2131* @return : success: 0 when successfully parsed2132* failure: 1 when failed to parse one more more lines2133* -1 when other critical errors (dlopen () etc)2134*2135* We have multiple returns here because for critical errors, we abort2136* operations immediately and exit. For example, if we can't load the2137* NFS server library, then we have a real bad problem so we don't continue.2138* Or if we cannot allocate anymore memory, we don't want to continue. Also,2139* we want to print out a different error messages based on the ret value.2140*/2141static int2142print_netgroups_file(const char *netgroups_file)2143{2144void *libhandle = NULL;2145char *libpathfull = NULL;2146struct netgroups_file *file = NULL;2147int ret = 0;2148}2215{2221int process_mode = 0;2222int ret = 0;2223struct stat stbuf = {22240,2225};2226char timestr[GF_TIMESTR_SIZE];2227char tmp_logfile[1024] = {0};2228char *tmp_logfile_dyn = NULL;2229char *tmp_logfilebase = NULL;2230cmd_args_t *cmd_args = NULL;2231int len = 0;2232char *thin_volfileid = NULL;2233specified. This is needed as 0 is a valid option, and may not be2244default value. */2245cmd_args->lru_limit = -1;2246* except for printing & verifying the netgroups file.2258*/2259ret = 0;2260goto out;2261}2262* except for printing & verifying the exports file.2266*/2267ret = 0;2268goto out;2269}2270given, then '--volfile-id' is mandatory */2287if (cmd_args->volfile_server && !cmd_args->volfile_id) {2288gf_smsg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_15, NULL);2289ret = -1;2290goto out;2291}2292and exit */2303ret = sys_stat(cmd_args->volfile, &stbuf);2304if (ret) {2305gf_smsg("glusterfs", GF_LOG_CRITICAL, errno, glusterfsd_msg_16,2306NULL);2307/* argp_usage (argp.) */2308fprintf(stderr, "USAGE: %s [options] [mountpoint]\n", argv[0]);2309goto out;2310}2311}2312* let it use the same, no need to alter2326*/2327if (((ret == 0) &&2328(S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) ||2329(ret == -1)) {2330/* Have separate logfile per run. */2331gf_time_fmt_FT(timestr, sizeof timestr, gf_time());2332sprintf(tmp_logfile, "%s.%s.%d", cmd_args->log_file, timestr,2333getpid());2334This option was made obsolete but parsing it for backward2355compatibility with third party applications2356*/2357if (cmd_args->max_connect_attempts) {2358gf_smsg("glusterfs", GF_LOG_WARNING, 0, glusterfsd_msg_33, NULL);2359}2360}2370{2374cmd_args_t *cmd_args = NULL;2375int ret = -1;2376FILE *pidfp = NULL;2377}2397{2401cmd_args_t *cmd_args = NULL;2402int ret = 0;2403FILE *pidfp = NULL;2404}2444{2448sigset_t set;2449int ret = 0;2450int sig = 0;2451char *file = NULL;2452}2491{2495gf_print_trace(signum, glusterfsd_ctx);2496}2497{2501sigset_t set;2502int ret = 0;2503TODO:2537fallback to signals getting handled by other threads.2538setup the signal handlers2539*/2540gf_smsg("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_23, NULL);2541return ret;2542}2543}2546{2550int ret = -1;2551cmd_args_t *cmd_args = NULL;2552int cstatus = 0;2553int err = 1;2554int child_pid = 0;2555and parent will just not wait for child status2573*/2574ctx->daemon_pipe[0] = -1;2575ctx->daemon_pipe[1] = -1;2576}2577will be available to parent process on calling exit() */2615if (err)2616_exit(abs(err));2617or process is spawned in no daemon mode2630*/2631if ((ctx->process_mode != GF_GLUSTERD_PROCESS) ||2632(cmd_args->no_daemon_mode)) {2633ret = glusterfs_pidfile_update(ctx, getpid());2634if (ret)2635goto out;2636}2637gf_log("glusterfs", GF_LOG_INFO, "Pid of current running process is %d",2638getpid());2639ret = gf_log_inject_timer_event(ctx);2640}2645{2650int ret = -1;2651cmd_args_t *cmd_args = NULL;2652int fd = -1;2653size_t oom_score_len = 0;2654struct oom_api_info *api = NULL;2655}2685#endif2686int2688glusterfs_process_volfp(glusterfs_ctx_t *ctx, FILE *fp)2689{2690glusterfs_graph_t *graph = NULL;2691int ret = -1;2692xlator_t *trav = NULL;2693client as well as servers.For now it destroys2736graph only for server-side xlators not for client-side2737xlators, before destroying a graph call xlator fini for2738xlators those call xlator_init to avoid leak2739*/2740if (graph) {2741xl = graph->first;2742if ((ctx->active != graph) &&2743(xl && !strcmp(xl->type, "protocol/server"))) {2744/* Take dict ref for every graph xlator to avoid dict leak2745at the time of graph destroying2746*/2747glusterfs_graph_fini(graph);2748glusterfs_graph_destroy(graph);2749}2750}2751}2761{2765cmd_args_t *cmd_args = NULL;2766int ret = 0;2767}2787/* This is the only legal global pointer */2789glusterfs_ctx_t *glusterfsd_ctx;2790{2793// glusterfs_ctx_destroy (ctx);2794gf_async_fini();2795}2798{2801int32_t res;2802* supports multithreaded I/O without io_uring. */2807res = gf_async_init(global_ctx);2808if (res < 0) {2809goto out;2810}2811}2844int2846main(int argc, char *argv[])2847{2848gf_io_handlers_t main_handlers = {.setup = main_start,2849.cleanup = main_terminate};2850glusterfs_ctx_t *ctx = NULL;2851int ret = -1;2852char cmdlinestr[PATH_MAX] = {28530,2854};2855cmd_args_t *cmd = NULL;2856* set the return value (exit code in this case) and exit.2906*/2907ret = print_netgroups_file(cmd->print_netgroups);2908goto out;2909}2910* set the return value (exit code in this case)2914* and exit.2915*/2916ret = print_exports_file(cmd->print_exports);2917goto out;2918}2919command line options. */2933{2934int i = 0;2935int pos = 0;2936int len = snprintf(cmdlinestr, sizeof(cmdlinestr), "%s", argv[0]);2937for (i = 1; (i < argc) && (len > 0); i++) {2938pos += len;2939len = snprintf(cmdlinestr + pos, sizeof(cmdlinestr) - pos, " %s",2940argv[i]);2941if ((len <= 0) || (len >= (sizeof(cmdlinestr) - pos))) {2942gf_smsg("glusterfs", GF_LOG_ERROR, 0, glusterfsd_msg_029, NULL);2943ret = -1;2944goto out;2945}2946}2947gf_smsg(argv[0], GF_LOG_INFO, 0, glusterfsd_msg_30, "arg=%s", argv[0],2948"version=%s", PACKAGE_VERSION, "cmdlinestr=%s", cmdlinestr,2949NULL);2950* not be cloned into the child process and would die with the parent.2966* After this point, there are several initialization functions that2967* can start additional threads. Let's call them from inside the I/O2968* framework context so that they can decide if a new thread is needed2969* or use the I/O framework for the functionalities they need. */2970ret = gf_io_run(cmd->io_engine, &main_handlers, NULL);2971}2975