LU-8080 utils: Replace calls to signal with sigaction

[fs/lustre-release.git] / lustre / utils / lhsmtool_posix.c

diff --git a/lustre/utils/lhsmtool_posix.c b/lustre/utils/lhsmtool_posix.c
index 8eef8e6..d99fce3 100644 (file)
--- a/lustre/utils/lhsmtool_posix.c
+++ b/lustre/utils/lhsmtool_posix.c
@@ -23,7 +23,7 @@
  * (C) Copyright 2012 Commissariat a l'energie atomique et aux energies
  *     alternatives
  *
- * Copyright (c) 2013, 2014, Intel Corporation.
+ * Copyright (c) 2013, 2015, Intel Corporation.
  */
 /* HSM copytool program for POSIX filesystem-based HSM's.
  *
@@ -37,19 +37,26 @@
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
+#include <ctype.h>
+#include <fcntl.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 #include <dirent.h>
 #include <errno.h>
 #include <getopt.h>
 #include <pthread.h>
 #include <time.h>
+#include <unistd.h>
 #include <utime.h>
+#include <signal.h>
 #include <sys/time.h>
 #include <sys/xattr.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
+
+#include <libcfs/util/string.h>
 #include <lustre/lustre_idl.h>
 #include <lustre/lustreapi.h>
 
@@ -517,7 +524,7 @@ static int ct_copy_data(struct hsm_copyaction_private *hcp, const char *src,
        struct stat              dst_st;
        char                    *buf = NULL;
        __u64                    write_total = 0;
-       __u64                    length;
+       __u64                    length = hai->hai_extent.length;
        time_t                   last_report_time;
        int                      rc = 0;
        double                   start_ct_now = ct_now();
@@ -540,8 +547,9 @@ static int ct_copy_data(struct hsm_copyaction_private *hcp, const char *src,
 
        if (hai->hai_extent.offset > (__u64)src_st.st_size) {
                rc = -EINVAL;
-               CT_ERROR(rc, "Trying to start reading past end ("LPU64" > "
-                        "%jd) of '%s' source file", hai->hai_extent.offset,
+               CT_ERROR(rc, "Trying to start reading past end (%ju > "
+                        "%jd) of '%s' source file",
+                        (uintmax_t)hai->hai_extent.offset,
                         (intmax_t)src_st.st_size, src);
                return rc;
        }
@@ -559,8 +567,8 @@ static int ct_copy_data(struct hsm_copyaction_private *hcp, const char *src,
        }
 
        /* Don't read beyond a given extent */
-       length = min(hai->hai_extent.length,
-                    src_st.st_size - hai->hai_extent.offset);
+       if (length > src_st.st_size - hai->hai_extent.offset)
+               length = src_st.st_size - hai->hai_extent.offset;
 
        start_time = last_bw_print = last_report_time = time(NULL);
 
@@ -583,8 +591,8 @@ static int ct_copy_data(struct hsm_copyaction_private *hcp, const char *src,
                goto out;
        }
 
-       CT_TRACE("start copy of "LPU64" bytes from '%s' to '%s'",
-                length, src, dst);
+       CT_TRACE("start copy of %ju bytes from '%s' to '%s'",
+                (uintmax_t)length, src, dst);
 
        while (write_total < length) {
                ssize_t rsize;
@@ -657,8 +665,10 @@ static int ct_copy_data(struct hsm_copyaction_private *hcp, const char *src,
                now = time(NULL);
                if (now >= last_report_time + opt.o_report_int) {
                        last_report_time = now;
-                       CT_TRACE("%%"LPU64" ", 100 * write_total / length);
-                       he.length = write_total;
+                       CT_TRACE("%%%ju ", (uintmax_t)(100 * write_total / length));
+                       /* only give the length of the write since the last
+                        * progress report */
+                       he.length = offset - he.offset;
                        rc = llapi_hsm_action_progress(hcp, &he, length, 0);
                        if (rc < 0) {
                                /* Action has been canceled or something wrong
@@ -667,6 +677,7 @@ static int ct_copy_data(struct hsm_copyaction_private *hcp, const char *src,
                                         " '%s'->'%s' failed", src, dst);
                                goto out;
                        }
+                       he.offset = offset;
                }
                rc = 0;
        }
@@ -695,8 +706,8 @@ out:
        if (buf != NULL)
                free(buf);
 
-       CT_TRACE("copied "LPU64" bytes in %f seconds",
-                length, ct_now() - start_ct_now);
+       CT_TRACE("copied %ju bytes in %f seconds",
+                (uintmax_t)length, ct_now() - start_ct_now);
 
        return rc;
 }
@@ -830,8 +841,8 @@ static int ct_fini(struct hsm_copyaction_private **phcp,
        int                              rc;
 
        CT_TRACE("Action completed, notifying coordinator "
-                "cookie="LPX64", FID="DFID", hp_flags=%d err=%d",
-                hai->hai_cookie, PFID(&hai->hai_fid),
+                "cookie=%#jx, FID="DFID", hp_flags=%d err=%d",
+                (uintmax_t)hai->hai_cookie, PFID(&hai->hai_fid),
                 hp_flags, -ct_rc);
 
        ct_path_lustre(lstr, sizeof(lstr), opt.o_mnt, &hai->hai_fid);
@@ -849,8 +860,8 @@ static int ct_fini(struct hsm_copyaction_private **phcp,
        rc = llapi_hsm_action_end(phcp, &hai->hai_extent, hp_flags, abs(ct_rc));
        if (rc == -ECANCELED)
                CT_ERROR(rc, "completed action on '%s' has been canceled: "
-                        "cookie="LPX64", FID="DFID, lstr, hai->hai_cookie,
-                        PFID(&hai->hai_fid));
+                        "cookie=%#jx, FID="DFID, lstr,
+                        (uintmax_t)hai->hai_cookie, PFID(&hai->hai_fid));
        else if (rc < 0)
                CT_ERROR(rc, "llapi_hsm_action_end() on '%s' failed", lstr);
        else
@@ -1271,9 +1282,9 @@ static int ct_process_item(struct hsm_action_item *hai, const long hal_flags)
                int             linkno = 0;
 
                sprintf(fid, DFID, PFID(&hai->hai_fid));
-               CT_TRACE("'%s' action %s reclen %d, cookie="LPX64,
+               CT_TRACE("'%s' action %s reclen %d, cookie=%#jx",
                         fid, hsm_copytool_action2name(hai->hai_action),
-                        hai->hai_len, hai->hai_cookie);
+                        hai->hai_len, (uintmax_t)hai->hai_cookie);
                rc = llapi_fid2path(opt.o_mnt, fid, path,
                                    sizeof(path), &recno, &linkno);
                if (rc < 0)
@@ -1756,7 +1767,7 @@ static int ct_max_sequence(void)
                path[sizeof(path) - 1] = '\0';
        }
 
-       printf("max_sequence: "LPX64"\n", seq);
+       printf("max_sequence: %#jx\n", (uintmax_t)seq);
 
        return 0;
 }
@@ -1779,7 +1790,8 @@ static void handler(int signal)
 /* Daemon waits for messages from the kernel; run it in the background. */
 static int ct_run(void)
 {
-       int     rc;
+       struct sigaction cleanup_sigaction;
+       int rc;
 
        if (opt.o_daemonize) {
                rc = daemon(1, 1);
@@ -1809,14 +1821,17 @@ static int ct_run(void)
                return rc;
        }
 
-       signal(SIGINT, handler);
-       signal(SIGTERM, handler);
+       memset(&cleanup_sigaction, 0, sizeof(cleanup_sigaction));
+       cleanup_sigaction.sa_handler = handler;
+       sigemptyset(&cleanup_sigaction.sa_mask);
+       sigaction(SIGINT, &cleanup_sigaction, NULL);
+       sigaction(SIGTERM, &cleanup_sigaction, NULL);
 
        while (1) {
-               struct hsm_action_list  *hal;
-               struct hsm_action_item  *hai;
-               int                      msgsize;
-               int                      i = 0;
+               struct hsm_action_list *hal;
+               struct hsm_action_item *hai;
+               int msgsize;
+               int i = 0;
 
                CT_TRACE("waiting for message from kernel");