ctdb-locking: Start locking helper using ctdb_vfork_exec

This avoids the extra argument of logfd to ctdb_lock_helper.  The log
messages from lock helper are captured by ctdbd.

Signed-off-by: Amitay Isaacs <amitay@gmail.com>
Reviewed-by: Martin Schwenke <martin@meltin.net>

diff --git a/ctdb/server/ctdb_lock.c b/ctdb/server/ctdb_lock.c
index 139ead02eac23f74d4f0be0a10173008182c63ba..0203369c3c228f2d5a9e5ff13115037977964752 100644 (file)
--- a/ctdb/server/ctdb_lock.c
+++ b/ctdb/server/ctdb_lock.c
@@ -661,9 +661,9 @@ static void ctdb_lock_schedule(struct ctdb_context *ctdb)
                return;
        }
 
-       if (!ctdb_vfork_with_logging(lock_ctx, ctdb, "lock_helper",
-                                    prog, argc, (const char **)args,
-                                    NULL, NULL, &lock_ctx->child)) {
+       lock_ctx->child = ctdb_vfork_exec(lock_ctx, ctdb, prog, argc,
+                                         (const char **)args);
+       if (lock_ctx->child == -1) {
                DEBUG(DEBUG_ERR, ("Failed to create a child in ctdb_lock_schedule\n"));
                close(lock_ctx->fd[0]);
                close(lock_ctx->fd[1]);

diff --git a/ctdb/server/ctdb_lock_helper.c b/ctdb/server/ctdb_lock_helper.c
index d7f8fe146f7c51f04395eb69bfc0c6dc7e4bb324..34823fb9153f62a561e58f856c2ccc09f9d30f4d 100644 (file)
--- a/ctdb/server/ctdb_lock_helper.c
+++ b/ctdb/server/ctdb_lock_helper.c
@@ -49,8 +49,7 @@ static void set_priority(void)
        realtime = set_scheduler();
        if (! realtime) {
                fprintf(stderr,
-                       "%s: Unable to set real-time scheduler priority\n",
-                       progname);
+                       "locking: Unable to set real-time scheduler priority\n");
        }
 }
 
@@ -73,10 +72,8 @@ static void send_result(int fd, char result)
 static void usage(void)
 {
        fprintf(stderr, "\n");
-       fprintf(stderr, "Usage: %s <log-fd> <ctdbd-pid> <output-fd> RECORD <db-path> <db-flags> <db-key>\n",
-               progname);
-       fprintf(stderr, "       %s <log-fd> <ctdbd-pid> <output-fd> DB <db1-path> <db1-flags> [<db2-path> <db2-flags>...]\n",
-               progname);
+       fprintf(stderr, "Usage: %s <ctdbd-pid> <output-fd> RECORD <db-path> <db-flags> <db-key>\n", progname);
+       fprintf(stderr, "       %s <ctdbd-pid> <output-fd> DB <db1-path> <db1-flags> [<db2-path> <db2-flags>...]\n", progname);
 }
 
 static uint8_t *hex_decode_talloc(TALLOC_CTX *mem_ctx,
@@ -115,15 +112,15 @@ static int lock_record(const char *dbpath, const char *dbflags, const char *dbke
 
        tdb = tdb_open(dbpath, 0, tdb_flags, O_RDWR, 0600);
        if (tdb == NULL) {
-               fprintf(stderr, "%s: Error opening database %s\n", progname, dbpath);
+               fprintf(stderr, "locking: Error opening database %s\n", dbpath);
                return 1;
        }
 
        set_priority();
 
        if (tdb_chainlock(tdb, key) < 0) {
-               fprintf(stderr, "%s: Error getting record lock (%s)\n",
-                       progname, tdb_errorstr(tdb));
+               fprintf(stderr, "locking: Error getting record lock (%s)\n",
+                       tdb_errorstr(tdb));
                return 1;
        }
 
@@ -144,15 +141,15 @@ static int lock_db(const char *dbpath, const char *dbflags)
 
        tdb = tdb_open(dbpath, 0, tdb_flags, O_RDWR, 0600);
        if (tdb == NULL) {
-               fprintf(stderr, "%s: Error opening database %s\n", progname, dbpath);
+               fprintf(stderr, "locking: Error opening database %s\n", dbpath);
                return 1;
        }
 
        set_priority();
 
        if (tdb_lockall(tdb) < 0) {
-               fprintf(stderr, "%s: Error getting db lock (%s)\n",
-                       progname, tdb_errorstr(tdb));
+               fprintf(stderr, "locking: Error getting db lock (%s)\n",
+                       tdb_errorstr(tdb));
                return 1;
        }
 
@@ -164,7 +161,7 @@ static int lock_db(const char *dbpath, const char *dbflags)
 
 int main(int argc, char *argv[])
 {
-       int write_fd, log_fd;
+       int write_fd;
        char result = 0;
        int ppid;
        const char *lock_type;
@@ -173,37 +170,31 @@ int main(int argc, char *argv[])
 
        progname = argv[0];
 
-       if (argc < 5) {
+       if (argc < 4) {
                usage();
                exit(1);
        }
 
-       log_fd = atoi(argv[1]);
-       close(STDOUT_FILENO);
-       close(STDERR_FILENO);
-       dup2(log_fd, STDOUT_FILENO);
-       dup2(log_fd, STDERR_FILENO);
-       close(log_fd);
-
-       ppid = atoi(argv[2]);
-       write_fd = atoi(argv[3]);
-       lock_type = argv[4];
+       ppid = atoi(argv[1]);
+       write_fd = atoi(argv[2]);
+       lock_type = argv[3];
 
        if (strcmp(lock_type, "RECORD") == 0) {
-               if (argc != 8) {
-                       fprintf(stderr, "%s: Invalid number of arguments (%d)\n",
-                               progname, argc);
+               if (argc != 7) {
+                       fprintf(stderr,
+                               "locking: Invalid number of arguments (%d)\n",
+                               argc);
                        usage();
                        exit(1);
                }
-               result = lock_record(argv[5], argv[6], argv[7]);
+               result = lock_record(argv[4], argv[5], argv[6]);
 
        } else if (strcmp(lock_type, "DB") == 0) {
                int n;
 
                /* If there are no databases specified, no need for lock */
-               if (argc > 5) {
-                       for (n=5; n+1<argc; n+=2) {
+               if (argc > 4) {
+                       for (n=4; n+1<argc; n+=2) {
                                result = lock_db(argv[n], argv[n+1]);
                                if (result != 0) {
                                        break;
@@ -212,7 +203,7 @@ int main(int argc, char *argv[])
                }
 
        } else {
-               fprintf(stderr, "%s: Invalid lock-type '%s'\n", progname, lock_type);
+               fprintf(stderr, "locking: Invalid lock-type '%s'\n", lock_type);
                usage();
                exit(1);
        }