#include <sys/syscall.h>
#include <fnmatch.h>
#include <glob.h>
+#include <signal.h>
#ifdef HAVE_LINUX_UNISTD_H
#include <linux/unistd.h>
#else
#include <unistd.h>
#endif
-#include <liblustre.h>
+#include <libcfs/libcfs.h>
#include <lnet/lnetctl.h>
-#include <obd.h>
-#include <obd_lov.h>
+#include <lustre/lustre_idl.h>
#include <lustre/lustreapi.h>
#include "lustreapi_internal.h"
+#define OPEN_BY_FID_PATH dot_lustre_name"/fid"
+
/****** HSM Copytool API ********/
#define CT_PRIV_MAGIC 0xC0BE2001
struct hsm_copytool_private {
int magic;
char *mnt;
int mnt_fd;
+ int open_by_fid_fd;
lustre_kernelcomm kuc;
__u32 archives;
};
__s32 data_fd;
const struct hsm_copytool_private *ct_priv;
struct hsm_copy copy;
+ struct stat stat;
};
#include <libcfs/libcfs.h>
+enum ct_progress_type {
+ CT_START = 0,
+ CT_RUNNING = 50,
+ CT_FINISH = 100,
+ CT_CANCEL = 150,
+ CT_ERROR = 175
+};
+
+enum ct_event {
+ CT_REGISTER = 1,
+ CT_UNREGISTER = 2,
+ CT_ARCHIVE_START = HSMA_ARCHIVE,
+ CT_ARCHIVE_RUNNING = HSMA_ARCHIVE + CT_RUNNING,
+ CT_ARCHIVE_FINISH = HSMA_ARCHIVE + CT_FINISH,
+ CT_ARCHIVE_CANCEL = HSMA_ARCHIVE + CT_CANCEL,
+ CT_ARCHIVE_ERROR = HSMA_ARCHIVE + CT_ERROR,
+ CT_RESTORE_START = HSMA_RESTORE,
+ CT_RESTORE_RUNNING = HSMA_RESTORE + CT_RUNNING,
+ CT_RESTORE_FINISH = HSMA_RESTORE + CT_FINISH,
+ CT_RESTORE_CANCEL = HSMA_RESTORE + CT_CANCEL,
+ CT_RESTORE_ERROR = HSMA_RESTORE + CT_ERROR,
+ CT_REMOVE_START = HSMA_REMOVE,
+ CT_REMOVE_RUNNING = HSMA_REMOVE + CT_RUNNING,
+ CT_REMOVE_FINISH = HSMA_REMOVE + CT_FINISH,
+ CT_REMOVE_CANCEL = HSMA_REMOVE + CT_CANCEL,
+ CT_REMOVE_ERROR = HSMA_REMOVE + CT_ERROR,
+ CT_EVENT_MAX
+};
+
+/* initialized in llapi_hsm_register_event_fifo() */
+int llapi_hsm_event_fd = -1;
+
+static inline const char *llapi_hsm_ct_ev2str(int type)
+{
+ switch (type) {
+ case CT_REGISTER:
+ return "REGISTER";
+ case CT_UNREGISTER:
+ return "UNREGISTER";
+ case CT_ARCHIVE_START:
+ return "ARCHIVE_START";
+ case CT_ARCHIVE_RUNNING:
+ return "ARCHIVE_RUNNING";
+ case CT_ARCHIVE_FINISH:
+ return "ARCHIVE_FINISH";
+ case CT_ARCHIVE_CANCEL:
+ return "ARCHIVE_CANCEL";
+ case CT_ARCHIVE_ERROR:
+ return "ARCHIVE_ERROR";
+ case CT_RESTORE_START:
+ return "RESTORE_START";
+ case CT_RESTORE_RUNNING:
+ return "RESTORE_RUNNING";
+ case CT_RESTORE_FINISH:
+ return "RESTORE_FINISH";
+ case CT_RESTORE_CANCEL:
+ return "RESTORE_CANCEL";
+ case CT_RESTORE_ERROR:
+ return "RESTORE_ERROR";
+ case CT_REMOVE_START:
+ return "REMOVE_START";
+ case CT_REMOVE_RUNNING:
+ return "REMOVE_RUNNING";
+ case CT_REMOVE_FINISH:
+ return "REMOVE_FINISH";
+ case CT_REMOVE_CANCEL:
+ return "REMOVE_CANCEL";
+ case CT_REMOVE_ERROR:
+ return "REMOVE_ERROR";
+ default:
+ llapi_err_noerrno(LLAPI_MSG_ERROR,
+ "Unknown event type: %d", type);
+ return NULL;
+ }
+}
+
+/**
+ * Writes a JSON event to the monitor FIFO. Noop if no FIFO has been
+ * registered.
+ *
+ * \param event A list of llapi_json_items comprising a
+ * single JSON-formatted event.
+ *
+ * \retval 0 on success.
+ * \retval -errno on error.
+ */
+int llapi_hsm_write_json_event(struct llapi_json_item_list **event)
+{
+ int rc;
+ char time_string[40];
+ char json_buf[PIPE_BUF];
+ FILE *buf_file;
+ time_t event_time = time(0);
+ struct tm time_components;
+ struct llapi_json_item_list *json_items;
+
+ /* Noop unless the event fd was initialized */
+ if (llapi_hsm_event_fd < 0)
+ return 0;
+
+ if (event == NULL || *event == NULL)
+ return -EINVAL;
+
+ json_items = *event;
+
+ localtime_r(&event_time, &time_components);
+
+ if (strftime(time_string, sizeof(time_string), "%Y-%m-%d %T %z",
+ &time_components) == 0) {
+ rc = -EINVAL;
+ llapi_error(LLAPI_MSG_ERROR, rc, "strftime() failed");
+ return rc;
+ }
+
+ rc = llapi_json_add_item(&json_items, "event_time", LLAPI_JSON_STRING,
+ time_string);
+ if (rc < 0) {
+ llapi_error(LLAPI_MSG_ERROR, -rc, "error in "
+ "llapi_json_add_item()");
+ return rc;
+ }
+
+ buf_file = fmemopen(json_buf, sizeof(json_buf), "w");
+ if (buf_file == NULL)
+ return -errno;
+
+ rc = llapi_json_write_list(event, buf_file);
+ if (rc < 0) {
+ fclose(buf_file);
+ return rc;
+ }
+
+ fclose(buf_file);
+
+ if (write(llapi_hsm_event_fd, json_buf, strlen(json_buf)) < 0) {
+ /* Ignore write failures due to missing reader. */
+ if (errno != EPIPE)
+ return -errno;
+ }
+
+ return 0;
+}
+
+/**
+ * Hook for llapi_hsm_copytool_register and llapi_hsm_copytool_unregister
+ * to generate JSON events suitable for consumption by a copytool
+ * monitoring process.
+ *
+ * \param priv Opaque private control structure.
+ * \param event_type The type of event (register or unregister).
+ *
+ * \retval 0 on success.
+ * \retval -errno on error.
+ */
+int llapi_hsm_log_ct_registration(struct hsm_copytool_private **priv,
+ __u32 event_type)
+{
+ int rc;
+ char agent_uuid[UUID_MAX];
+ struct hsm_copytool_private *ct;
+ struct llapi_json_item_list *json_items;
+
+ if (priv == NULL || *priv == NULL)
+ return -EINVAL;
+
+ ct = *priv;
+ if (ct->magic != CT_PRIV_MAGIC)
+ return -EINVAL;
+
+ if (event_type != CT_REGISTER && event_type != CT_UNREGISTER)
+ return -EINVAL;
+
+ rc = llapi_json_init_list(&json_items);
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_get_agent_uuid(ct->mnt, agent_uuid, sizeof(agent_uuid));
+ if (rc < 0)
+ goto err;
+ llapi_chomp_string(agent_uuid);
+
+ rc = llapi_json_add_item(&json_items, "uuid", LLAPI_JSON_STRING,
+ agent_uuid);
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_json_add_item(&json_items, "mount_point", LLAPI_JSON_STRING,
+ ct->mnt);
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_json_add_item(&json_items, "archive", LLAPI_JSON_INTEGER,
+ &ct->archives);
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_json_add_item(&json_items, "event_type", LLAPI_JSON_STRING,
+ (char *)llapi_hsm_ct_ev2str(event_type));
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_hsm_write_json_event(&json_items);
+ if (rc < 0)
+ goto err;
+
+ goto out_free;
+
+err:
+ llapi_error(LLAPI_MSG_ERROR, rc, "error in "
+ "llapi_hsm_log_ct_registration()");
+
+out_free:
+ if (json_items != NULL)
+ llapi_json_destroy_list(&json_items);
+
+ return rc;
+}
+
+/**
+ * Given a copytool progress update, construct a JSON event suitable for
+ * consumption by a copytool monitoring process.
+ *
+ * Examples of various events generated here and written by
+ * llapi_hsm_write_json_event:
+ *
+ * Copytool registration and deregistration:
+ * {"event_time": "2014-02-26 14:58:01 -0500", "event_type": "REGISTER",
+ * "archive": 0, "mount_point": "/mnt/lustre",
+ * "uuid": "80379a60-1f8a-743f-daf2-307cde793ec2"}
+ * {"event_time": "2014-02-26 14:58:01 -0500", "event_type": "UNREGISTER",
+ * "archive": 0, "mount_point": "/mnt/lustre",
+ * "uuid": "80379a60-1f8a-743f-daf2-307cde793ec2"}
+ *
+ * An archive action, start to completion:
+ * {"event_time": "2014-02-26 14:50:13 -0500", "event_type": "ARCHIVE_START",
+ * "total_bytes": 0, "lustre_path": "d71.sanity-hsm/f71.sanity-hsm",
+ * "source_fid": "0x2000013a1:0x2:0x0", "data_fid": "0x2000013a1:0x2:0x0"}
+ * {"event_time": "2014-02-26 14:50:18 -0500", "event_type": "ARCHIVE_RUNNING",
+ * "current_bytes": 5242880, "total_bytes": 39000000,
+ * "lustre_path": "d71.sanity-hsm/f71.sanity-hsm",
+ * "source_fid": "0x2000013a1:0x2:0x0", "data_fid": "0x2000013a1:0x2:0x0"}
+ * {"event_time": "2014-02-26 14:50:50 -0500", "event_type": "ARCHIVE_FINISH",
+ * "source_fid": "0x2000013a1:0x2:0x0", "data_fid": "0x2000013a1:0x2:0x0"}
+ *
+ * A log message:
+ * {"event_time": "2014-02-26 14:50:13 -0500", "event_type": "LOGGED_MESSAGE",
+ * "level": "INFO",
+ * "message": "lhsmtool_posix[42]: copytool fs=lustre archive#=2 item_count=1"}
+ *
+ * \param hcp Opaque action handle returned by
+ * llapi_hsm_action_start.
+ * \param hai The hsm_action_item describing the request.
+ * \param progress_type The ct_progress_type describing the update.
+ * \param total The total expected bytes for the request.
+ * \param current The current copied byte count for the request.
+ *
+ * \retval 0 on success.
+ * \retval -errno on error.
+ */
+int llapi_hsm_log_ct_progress(struct hsm_copyaction_private **phcp,
+ const struct hsm_action_item *hai, __u32 progress_type,
+ __u64 total, __u64 current)
+{
+ int rc;
+ int linkno = 0;
+ long long recno = -1;
+ char lustre_path[PATH_MAX];
+ char strfid[FID_NOBRACE_LEN + 1];
+ struct hsm_copyaction_private *hcp;
+ struct llapi_json_item_list *json_items;
+
+ if (phcp == NULL || *phcp == NULL)
+ return -EINVAL;
+
+ hcp = *phcp;
+
+ rc = llapi_json_init_list(&json_items);
+ if (rc < 0)
+ goto err;
+
+ snprintf(strfid, sizeof(strfid), DFID_NOBRACE, PFID(&hai->hai_dfid));
+ rc = llapi_json_add_item(&json_items, "data_fid",
+ LLAPI_JSON_STRING, strfid);
+ if (rc < 0)
+ goto err;
+
+ snprintf(strfid, sizeof(strfid), DFID_NOBRACE, PFID(&hai->hai_fid));
+ rc = llapi_json_add_item(&json_items, "source_fid",
+ LLAPI_JSON_STRING, strfid);
+ if (rc < 0)
+ goto err;
+
+ if (hcp->copy.hc_errval == ECANCELED) {
+ progress_type = CT_CANCEL;
+ goto cancel;
+ }
+
+ if (hcp->copy.hc_errval != 0) {
+ progress_type = CT_ERROR;
+
+ rc = llapi_json_add_item(&json_items, "errno",
+ LLAPI_JSON_INTEGER,
+ &hcp->copy.hc_errval);
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_json_add_item(&json_items, "error",
+ LLAPI_JSON_STRING,
+ strerror(hcp->copy.hc_errval));
+ if (rc < 0)
+ goto err;
+
+ goto cancel;
+ }
+
+ /* lustre_path isn't available after a restore completes */
+ /* total_bytes isn't available after a restore or archive completes */
+ if (progress_type != CT_FINISH) {
+ rc = llapi_fid2path(hcp->ct_priv->mnt, strfid, lustre_path,
+ sizeof(lustre_path), &recno, &linkno);
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_json_add_item(&json_items, "lustre_path",
+ LLAPI_JSON_STRING, lustre_path);
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_json_add_item(&json_items, "total_bytes",
+ LLAPI_JSON_BIGNUM, &total);
+ if (rc < 0)
+ goto err;
+ }
+
+ if (progress_type == CT_RUNNING)
+ rc = llapi_json_add_item(&json_items, "current_bytes",
+ LLAPI_JSON_BIGNUM, ¤t);
+ if (rc < 0)
+ goto err;
+
+cancel:
+ rc = llapi_json_add_item(&json_items, "event_type", LLAPI_JSON_STRING,
+ (char *)llapi_hsm_ct_ev2str(hai->hai_action +
+ progress_type));
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_hsm_write_json_event(&json_items);
+ if (rc < 0)
+ goto err;
+
+ goto out_free;
+
+err:
+ llapi_error(LLAPI_MSG_ERROR, rc, "error in "
+ "llapi_hsm_log_ct_progress()");
+
+out_free:
+ if (json_items != NULL)
+ llapi_json_destroy_list(&json_items);
+
+ return rc;
+}
+
+/**
+ * Given a path to a FIFO, create a filehandle for nonblocking writes to it.
+ * Intended to be used for copytool monitoring processes that read an
+ * event stream from the FIFO. Events written in the absence of a reader
+ * are lost.
+ *
+ * \param path Path to monitor FIFO.
+ *
+ * \retval 0 on success.
+ * \retval -errno on error.
+ */
+int llapi_hsm_register_event_fifo(char *path)
+{
+ int read_fd;
+ struct stat statbuf;
+
+ /* Create the FIFO if necessary. */
+ if ((mkfifo(path, 0644) < 0) && (errno != EEXIST)) {
+ llapi_error(LLAPI_MSG_ERROR, errno, "mkfifo(%s) failed", path);
+ return -errno;
+ }
+ if (errno == EEXIST) {
+ if (stat(path, &statbuf) < 0) {
+ llapi_error(LLAPI_MSG_ERROR, errno, "mkfifo(%s) failed",
+ path);
+ return -errno;
+ }
+ if (!S_ISFIFO(statbuf.st_mode) ||
+ ((statbuf.st_mode & 0777) != 0644)) {
+ llapi_error(LLAPI_MSG_ERROR, errno, "%s exists but is "
+ "not a pipe or has a wrong mode", path);
+ return -errno;
+ }
+ }
+
+ /* Open the FIFO for read so that the subsequent open for write
+ * doesn't immediately fail. */
+ read_fd = open(path, O_RDONLY | O_NONBLOCK);
+ if (read_fd < 0) {
+ llapi_error(LLAPI_MSG_ERROR, errno,
+ "cannot open(%s) for read", path);
+ return -errno;
+ }
+
+ /* Open the FIFO for writes, but don't block on waiting
+ * for a reader. */
+ llapi_hsm_event_fd = open(path, O_WRONLY | O_NONBLOCK);
+ if (llapi_hsm_event_fd < 0) {
+ llapi_error(LLAPI_MSG_ERROR, errno,
+ "cannot open(%s) for write", path);
+ return -errno;
+ }
+
+ /* Now close the reader. An external monitoring process can
+ * now open the FIFO for reads. If no reader comes along the
+ * events are lost. NOTE: Only one reader at a time! */
+ close(read_fd);
+
+ /* Ignore SIGPIPEs -- can occur if the reader goes away. */
+ signal(SIGPIPE, SIG_IGN);
+
+ return 0;
+}
+
+/**
+ * Given a path to a FIFO, close its filehandle and delete the FIFO.
+ *
+ * \param path Path to monitor FIFO.
+ *
+ * \retval 0 on success.
+ * \retval -errno on error.
+ */
+int llapi_hsm_unregister_event_fifo(char *path)
+{
+ /* Noop unless the event fd was initialized */
+ if (llapi_hsm_event_fd < 0)
+ return 0;
+
+ if (close(llapi_hsm_event_fd) < 0)
+ return -errno;
+
+ unlink(path);
+
+ llapi_hsm_event_fd = -1;
+
+ return 0;
+}
+
+/**
+ * Custom logging callback to be used when a monitoring FIFO has been
+ * registered. Formats log entries as JSON events suitable for
+ * consumption by a copytool monitoring process.
+ *
+ * \param level The message loglevel.
+ * \param _rc The returncode associated with the message.
+ * \param fmt The message format string.
+ * \param args Arguments to be formatted by the format string.
+ *
+ * \retval None.
+ */
+void llapi_hsm_log_error(enum llapi_message_level level, int _rc,
+ const char *fmt, va_list args)
+{
+ int rc;
+ int msg_len;
+ int real_level;
+ char *msg = NULL;
+ va_list args2;
+ struct llapi_json_item_list *json_items;
+
+ /* Noop unless the event fd was initialized */
+ if (llapi_hsm_event_fd < 0)
+ return;
+
+ rc = llapi_json_init_list(&json_items);
+ if (rc < 0)
+ goto err;
+
+ if ((level & LLAPI_MSG_NO_ERRNO) == 0) {
+ rc = llapi_json_add_item(&json_items, "errno",
+ LLAPI_JSON_INTEGER,
+ &_rc);
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_json_add_item(&json_items, "error",
+ LLAPI_JSON_STRING,
+ strerror(abs(_rc)));
+ if (rc < 0)
+ goto err;
+ }
+
+ va_copy(args2, args);
+ msg_len = vsnprintf(NULL, 0, fmt, args2) + 1;
+ va_end(args2);
+ if (msg_len >= 0) {
+ msg = (char *) alloca(msg_len);
+ if (msg == NULL) {
+ rc = -ENOMEM;
+ goto err;
+ }
+
+ rc = vsnprintf(msg, msg_len, fmt, args);
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_json_add_item(&json_items, "message",
+ LLAPI_JSON_STRING,
+ msg);
+ if (rc < 0)
+ goto err;
+ } else {
+ rc = llapi_json_add_item(&json_items, "message",
+ LLAPI_JSON_STRING,
+ "INTERNAL ERROR: message failed");
+ if (rc < 0)
+ goto err;
+ }
+
+ real_level = level & LLAPI_MSG_NO_ERRNO;
+ real_level = real_level > 0 ? level - LLAPI_MSG_NO_ERRNO : level;
+
+ rc = llapi_json_add_item(&json_items, "level", LLAPI_JSON_STRING,
+ (void *)llapi_msg_level2str(real_level));
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_json_add_item(&json_items, "event_type", LLAPI_JSON_STRING,
+ "LOGGED_MESSAGE");
+ if (rc < 0)
+ goto err;
+
+ rc = llapi_hsm_write_json_event(&json_items);
+ if (rc < 0)
+ goto err;
+
+ goto out_free;
+
+err:
+ /* Write directly to stderr to avoid llapi_error, which now
+ * emits JSON event messages. */
+ fprintf(stderr, "\nFATAL ERROR IN llapi_hsm_log_error(): rc %d,", rc);
+
+out_free:
+ if (json_items != NULL)
+ llapi_json_destroy_list(&json_items);
+
+ return;
+}
+
/** Register a copytool
* \param[out] priv Opaque private control structure
* \param mnt Lustre filesystem mount point
if (ct == NULL)
return -ENOMEM;
- ct->mnt_fd = open(mnt, O_DIRECTORY | O_RDONLY | O_NONBLOCK);
- if (ct->mnt_fd < 0) {
- rc = -errno;
- goto out_err;
- }
+ ct->magic = CT_PRIV_MAGIC;
+ ct->mnt_fd = -1;
+ ct->open_by_fid_fd = -1;
+ ct->kuc.lk_rfd = LK_NOFD;
+ ct->kuc.lk_wfd = LK_NOFD;
ct->mnt = strdup(mnt);
if (ct->mnt == NULL) {
goto out_err;
}
- ct->magic = CT_PRIV_MAGIC;
+ ct->mnt_fd = open(ct->mnt, O_RDONLY);
+ if (ct->mnt_fd < 0) {
+ rc = -errno;
+ goto out_err;
+ }
+
+ ct->open_by_fid_fd = openat(ct->mnt_fd, OPEN_BY_FID_PATH, O_RDONLY);
+ if (ct->open_by_fid_fd < 0) {
+ rc = -errno;
+ goto out_err;
+ }
/* no archives specified means "match all". */
ct->archives = 0;
for (rc = 0; rc < archive_count; rc++) {
if (archives[rc] > 8 * sizeof(ct->archives)) {
llapi_err_noerrno(LLAPI_MSG_ERROR,
- "Maximum of %d archives supported",
+ "maximum of %zu archives supported",
8 * sizeof(ct->archives));
goto out_err;
}
rc = 0;
}
+ llapi_hsm_log_ct_registration(&ct, CT_REGISTER);
+
/* Only the kernel reference keeps the write side open */
close(ct->kuc.lk_wfd);
- ct->kuc.lk_wfd = 0;
+ ct->kuc.lk_wfd = LK_NOFD;
if (rc < 0)
goto out_kuc;
out_err:
if (!(ct->mnt_fd < 0))
close(ct->mnt_fd);
+
+ if (!(ct->open_by_fid_fd < 0))
+ close(ct->open_by_fid_fd);
+
if (ct->mnt != NULL)
free(ct->mnt);
+
free(ct);
+
return rc;
}
/* Shut down the kernelcomms */
libcfs_ukuc_stop(&ct->kuc);
+ llapi_hsm_log_ct_registration(&ct, CT_UNREGISTER);
+
+ close(ct->open_by_fid_fd);
close(ct->mnt_fd);
free(ct->mnt);
free(ct);
return rc;
}
+static int ct_open_by_fid(const struct hsm_copytool_private *ct,
+ const struct lu_fid *fid, int open_flags)
+{
+ char fid_name[FID_NOBRACE_LEN + 1];
+
+ snprintf(fid_name, sizeof(fid_name), DFID_NOBRACE, PFID(fid));
+
+ return openat(ct->open_by_fid_fd, fid_name, open_flags);
+}
+
+static int ct_stat_by_fid(const struct hsm_copytool_private *ct,
+ const struct lu_fid *fid,
+ struct stat *buf)
+{
+ char fid_name[FID_NOBRACE_LEN + 1];
+
+ snprintf(fid_name, sizeof(fid_name), DFID_NOBRACE, PFID(fid));
+
+ return fstatat(ct->open_by_fid_fd, fid_name, buf, 0);
+}
+
/** Create the destination volatile file for a restore operation.
*
- * \param hcp Private copyaction handle.
+ * \param hcp Private copyaction handle.
+ * \param mdt_index MDT index where to create the volatile file.
+ * \param flags Volatile file creation flags.
* \return 0 on success.
*/
-static int create_restore_volatile(struct hsm_copyaction_private *hcp)
+static int create_restore_volatile(struct hsm_copyaction_private *hcp,
+ int mdt_index, int open_flags)
{
int rc;
int fd;
if (rc < 0) {
/* fid_parent() failed, try to keep on going */
llapi_error(LLAPI_MSG_ERROR, rc,
- "cannot get parent path to restore "DFID
+ "cannot get parent path to restore "DFID" "
"using '%s'", PFID(&hai->hai_fid), mnt);
snprintf(parent, sizeof(parent), "%s", mnt);
}
- fd = llapi_create_volatile_idx(parent, 0, O_LOV_DELAY_CREATE);
+ fd = llapi_create_volatile_idx(parent, mdt_index, open_flags);
if (fd < 0)
return fd;
+ rc = fchown(fd, hcp->stat.st_uid, hcp->stat.st_gid);
+ if (rc < 0)
+ goto err_cleanup;
+
rc = llapi_fd2fid(fd, &hai->hai_dfid);
if (rc < 0)
goto err_cleanup;
* It could be skipped if copytool only want to directly report an error,
* \see llapi_hsm_action_end().
*
- * \param hcp Opaque action handle to be passed to
- * llapi_hsm_action_progress and llapi_hsm_action_end.
- * \param ct Copytool handle acquired at registration.
- * \param hai The hsm_action_item describing the request.
- * \param is_error Whether this call is just to report an error.
+ * \param hcp Opaque action handle to be passed to
+ * llapi_hsm_action_progress and llapi_hsm_action_end.
+ * \param ct Copytool handle acquired at registration.
+ * \param hai The hsm_action_item describing the request.
+ * \param restore_mdt_index On restore: MDT index where to create the volatile
+ * file. Use -1 for default.
+ * \param restore_open_flags On restore: volatile file creation mode. Use
+ * O_LOV_DELAY_CREATE to manually set the LOVEA
+ * afterwards.
+ * \param is_error Whether this call is just to report an error.
*
* \return 0 on success.
*/
int llapi_hsm_action_begin(struct hsm_copyaction_private **phcp,
const struct hsm_copytool_private *ct,
- const struct hsm_action_item *hai, bool is_error)
+ const struct hsm_action_item *hai,
+ int restore_mdt_index, int restore_open_flags,
+ bool is_error)
{
struct hsm_copyaction_private *hcp;
int rc;
goto ok_out;
if (hai->hai_action == HSMA_RESTORE) {
- rc = create_restore_volatile(hcp);
+ rc = ct_stat_by_fid(hcp->ct_priv, &hai->hai_fid, &hcp->stat);
+ if (rc < 0)
+ goto err_out;
+
+ rc = create_restore_volatile(hcp, restore_mdt_index,
+ restore_open_flags);
if (rc < 0)
goto err_out;
}
goto err_out;
}
+ llapi_hsm_log_ct_progress(&hcp, hai, CT_START, 0, 0);
+
ok_out:
hcp->magic = CP_PRIV_MAGIC;
*phcp = hcp;
* \return 0 on success.
*/
int llapi_hsm_action_end(struct hsm_copyaction_private **phcp,
- const struct hsm_extent *he, int flags, int errval)
+ const struct hsm_extent *he, int hp_flags, int errval)
{
struct hsm_copyaction_private *hcp;
struct hsm_action_item *hai;
hai = &hcp->copy.hc_hai;
+ if (hai->hai_action == HSMA_RESTORE && errval == 0) {
+ struct timeval tv[2];
+
+ /* Set {a,m}time of volatile file to that of original. */
+ tv[0].tv_sec = hcp->stat.st_atime;
+ tv[0].tv_usec = 0;
+ tv[1].tv_sec = hcp->stat.st_mtime;
+ tv[1].tv_usec = 0;
+ if (futimes(hcp->data_fd, tv) < 0) {
+ errval = -errno;
+ goto end;
+ }
+
+ rc = fsync(hcp->data_fd);
+ if (rc < 0) {
+ errval = -errno;
+ goto end;
+ }
+ }
+
+end:
/* In some cases, like restore, 2 FIDs are used.
* Set the right FID to use here. */
if (hai->hai_action == HSMA_ARCHIVE || hai->hai_action == HSMA_RESTORE)
/* Fill the last missing data that will be needed by
* kernel to send a hsm_progress. */
- hcp->copy.hc_flags = flags;
+ hcp->copy.hc_flags = hp_flags;
hcp->copy.hc_errval = abs(errval);
hcp->copy.hc_hai.hai_extent = *he;
goto err_cleanup;
}
+ llapi_hsm_log_ct_progress(&hcp, hai, CT_FINISH, 0, 0);
+
err_cleanup:
if (!(hcp->data_fd < 0))
close(hcp->data_fd);
/** Notify a progress in processing an HSM action.
* \param hdl[in,out] handle returned by llapi_hsm_action_start.
* \param he[in] the range of copied data (for copy actions).
+ * \param total[in] the expected total of copied data (for copy actions).
* \param hp_flags[in] HSM progress flags.
* \return 0 on success.
*/
int llapi_hsm_action_progress(struct hsm_copyaction_private *hcp,
- const struct hsm_extent *he, int hp_flags)
+ const struct hsm_extent *he, __u64 total,
+ int hp_flags)
{
int rc;
struct hsm_progress hp;
if (rc < 0)
rc = -errno;
+ llapi_hsm_log_ct_progress(&hcp, hai, CT_RUNNING, total, he->length);
+
return rc;
}
if (hcp->magic != CP_PRIV_MAGIC)
return -EINVAL;
- if (hai->hai_action != HSMA_RESTORE)
+ if (hai->hai_action == HSMA_ARCHIVE)
+ return ct_open_by_fid(hcp->ct_priv, &hai->hai_dfid,
+ O_RDONLY | O_NOATIME | O_NOFOLLOW | O_NONBLOCK);
+ else if (hai->hai_action == HSMA_RESTORE)
+ return dup(hcp->data_fd);
+ else
return -EINVAL;
-
- return dup(hcp->data_fd);
}
/**
git://git.whamcloud.com / fs / lustre-release.git / blobdiff