X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Futils%2Fliblustreapi_hsm.c;h=9a36c6b27fdd558ed8eb9ae29e9f2e915e52345d;hb=refs%2Fchanges%2F67%2F6867%2F9;hp=c32fcfedc4bb8b888a112a0b002eab8be4e47017;hpb=780a5724177ab87ed088a1da484fb99c3f75c7c6;p=fs%2Flustre-release.git diff --git a/lustre/utils/liblustreapi_hsm.c b/lustre/utils/liblustreapi_hsm.c index c32fcfe..9a36c6b 100644 --- a/lustre/utils/liblustreapi_hsm.c +++ b/lustre/utils/liblustreapi_hsm.c @@ -26,7 +26,8 @@ * * Author: Aurelien Degremont * Author: JC Lafoucriere - * Author: Thomas leibovici + * Author: Thomas Leibovici + * Author: Henri Doreau */ #include @@ -58,35 +59,36 @@ #include #include "lustreapi_internal.h" -/* - * fake functions, real one will come with HSM flags patch - */ -static int llapi_hsm_state_set(const char *path, __u64 setmask, __u64 clearmask, - __u32 archive_num) -{ - return 0; -} - /****** HSM Copytool API ********/ #define CT_PRIV_MAGIC 0xC0BE2001 struct hsm_copytool_private { int magic; - char *fsname; + char *mnt; + int mnt_fd; lustre_kernelcomm kuc; __u32 archives; }; +#define CP_PRIV_MAGIC 0x19880429 +struct hsm_copyaction_private { + __u32 magic; + __s32 data_fd; + const struct hsm_copytool_private *ct_priv; + struct hsm_copy copy; +}; + #include /** Register a copytool * \param[out] priv Opaque private control structure - * \param fsname Lustre filesystem + * \param mnt Lustre filesystem mount point * \param flags Open flags, currently unused (e.g. O_NONBLOCK) * \param archive_count * \param archives Which archive numbers this copytool is responsible for */ -int llapi_hsm_copytool_start(void **priv, char *fsname, int flags, - int archive_count, int *archives) +int llapi_hsm_copytool_register(struct hsm_copytool_private **priv, + const char *mnt, int flags, int archive_count, + int *archives) { struct hsm_copytool_private *ct; int rc; @@ -101,12 +103,18 @@ int llapi_hsm_copytool_start(void **priv, char *fsname, int flags, if (ct == NULL) return -ENOMEM; - ct->fsname = malloc(strlen(fsname) + 1); - if (ct->fsname == NULL) { + ct->mnt_fd = open(mnt, O_DIRECTORY | O_RDONLY | O_NONBLOCK); + if (ct->mnt_fd < 0) { + rc = -errno; + goto out_err; + } + + ct->mnt = strdup(mnt); + if (ct->mnt == NULL) { rc = -ENOMEM; goto out_err; } - strcpy(ct->fsname, fsname); + ct->magic = CT_PRIV_MAGIC; /* no archives specified means "match all". */ @@ -114,7 +122,7 @@ int llapi_hsm_copytool_start(void **priv, char *fsname, int flags, 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; } @@ -135,71 +143,86 @@ int llapi_hsm_copytool_start(void **priv, char *fsname, int flags, /* Storing archive(s) in lk_data; see mdc_ioc_hsm_ct_start */ ct->kuc.lk_data = ct->archives; - rc = root_ioctl(ct->fsname, LL_IOC_HSM_CT_START, &(ct->kuc), NULL, - WANT_ERROR); - /* ignore if it was already registered on coordinator */ - if (rc == -EEXIST) + rc = ioctl(ct->mnt_fd, LL_IOC_HSM_CT_START, &ct->kuc); + if (rc < 0) { + rc = -errno; + llapi_error(LLAPI_MSG_ERROR, rc, + "cannot start copytool on '%s'", mnt); + goto out_err; + } else { rc = 0; + } + /* 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_err; + goto out_kuc; *priv = ct; return 0; +out_kuc: + /* cleanup the kuc channel */ + libcfs_ukuc_stop(&ct->kuc); + out_err: - if (ct->fsname) - free(ct->fsname); + if (!(ct->mnt_fd < 0)) + close(ct->mnt_fd); + if (ct->mnt != NULL) + free(ct->mnt); free(ct); return rc; } /** Deregister a copytool - * Note: under Linux, until llapi_hsm_copytool_fini is called (or the program is - * killed), the libcfs module will be referenced and unremovable, - * even after Lustre services stop. + * Note: under Linux, until llapi_hsm_copytool_unregister is called + * (or the program is killed), the libcfs module will be referenced + * and unremovable, even after Lustre services stop. */ -int llapi_hsm_copytool_fini(void **priv) +int llapi_hsm_copytool_unregister(struct hsm_copytool_private **priv) { struct hsm_copytool_private *ct; - ct = (struct hsm_copytool_private *)priv; - if (!ct || (ct->magic != CT_PRIV_MAGIC)) + if (priv == NULL || *priv == NULL) + return -EINVAL; + + ct = *priv; + if (ct->magic != CT_PRIV_MAGIC) return -EINVAL; /* Tell the kernel to stop sending us messages */ ct->kuc.lk_flags = LK_FLG_STOP; - root_ioctl(ct->fsname, LL_IOC_HSM_CT_START, &(ct->kuc), NULL, 0); + ioctl(ct->mnt_fd, LL_IOC_HSM_CT_START, &ct->kuc); /* Shut down the kernelcomms */ libcfs_ukuc_stop(&ct->kuc); - free(ct->fsname); + close(ct->mnt_fd); + free(ct->mnt); free(ct); *priv = NULL; + return 0; } /** Wait for the next hsm_action_list - * \param priv Opaque private control structure + * \param ct Opaque private control structure * \param halh Action list handle, will be allocated here * \param msgsize Number of bytes in the message, will be set here * \return 0 valid message received; halh and msgsize are set * <0 error code */ -int llapi_hsm_copytool_recv(void *priv, struct hsm_action_list **halh, - int *msgsize) +int llapi_hsm_copytool_recv(struct hsm_copytool_private *ct, + struct hsm_action_list **halh, int *msgsize) { - struct hsm_copytool_private *ct; - struct kuc_hdr *kuch; - struct hsm_action_list *hal; - int rc = 0; + struct kuc_hdr *kuch; + struct hsm_action_list *hal; + int rc = 0; - ct = (struct hsm_copytool_private *)priv; - if (!ct || (ct->magic != CT_PRIV_MAGIC)) + if (ct == NULL || ct->magic != CT_PRIV_MAGIC) return -EINVAL; + if (halh == NULL || msgsize == NULL) return -EINVAL; @@ -244,12 +267,12 @@ int llapi_hsm_copytool_recv(void *priv, struct hsm_action_list **halh, /* Check that we have registered for this archive # * if 0 registered, we serve any archive */ if (ct->archives && - ((1 << (hal->hal_archive_num - 1)) & ct->archives) == 0) { + ((1 << (hal->hal_archive_id - 1)) & ct->archives) == 0) { llapi_err_noerrno(LLAPI_MSG_INFO, "This copytool does not service archive #%d," " ignoring this request." " Mask of served archive is 0x%.8X", - hal->hal_archive_num, ct->archives); + hal->hal_archive_id, ct->archives); rc = -EAGAIN; goto out_free; @@ -267,125 +290,293 @@ out_free: } /** Release the action list when done with it. */ -int llapi_hsm_copytool_free(struct hsm_action_list **hal) +void llapi_hsm_action_list_free(struct hsm_action_list **hal) { /* Reuse the llapi_changelog_free function */ - return llapi_changelog_free((struct changelog_ext_rec **)hal); + llapi_changelog_free((struct changelog_ext_rec **)hal); +} + +/** Get parent path from mount point and fid. + * + * \param mnt Filesystem root path. + * \param fid Object FID. + * \param parent Destination buffer. + * \param parent_len Destination buffer size. + * \return 0 on success. + */ +static int fid_parent(const char *mnt, const lustre_fid *fid, char *parent, + size_t parent_len) +{ + int rc; + int linkno = 0; + long long recno = -1; + char file[PATH_MAX]; + char strfid[FID_NOBRACE_LEN + 1]; + char *ptr; + + snprintf(strfid, sizeof(strfid), DFID_NOBRACE, PFID(fid)); + + rc = llapi_fid2path(mnt, strfid, file, sizeof(file), + &recno, &linkno); + if (rc < 0) + return rc; + + /* fid2path returns a relative path */ + rc = snprintf(parent, parent_len, "%s/%s", mnt, file); + if (rc >= parent_len) + return -ENAMETOOLONG; + + /* remove file name */ + ptr = strrchr(parent, '/'); + if (ptr == NULL || ptr == parent) { + rc = -EINVAL; + } else { + *ptr = '\0'; + rc = 0; + } + + return rc; } +/** Create the destination volatile file for a restore operation. + * + * \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, + int mdt_index, int flags) +{ + int rc; + int fd; + char parent[PATH_MAX + 1]; + const char *mnt = hcp->ct_priv->mnt; + struct hsm_action_item *hai = &hcp->copy.hc_hai; + + rc = fid_parent(mnt, &hai->hai_fid, parent, sizeof(parent)); + if (rc < 0) { + /* fid_parent() failed, try to keep on going */ + llapi_error(LLAPI_MSG_ERROR, rc, + "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, mdt_index, flags); + if (fd < 0) + return fd; + + rc = llapi_fd2fid(fd, &hai->hai_dfid); + if (rc < 0) + goto err_cleanup; + + hcp->data_fd = fd; + + return 0; + +err_cleanup: + hcp->data_fd = -1; + close(fd); + + return rc; +} + +/** Start processing an HSM action. * Should be called by copytools just before starting handling a request. * It could be skipped if copytool only want to directly report an error, - * \see llapi_hsm_copy_end(). + * \see llapi_hsm_action_end(). * - * \param mnt Mount point of the corresponding Lustre filesystem. - * \param hai The hsm_action_item describing the request they will handle. - * \param copy Updated by this call. Caller will passed it to - * llapi_hsm_copy_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 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_copy_start(char *mnt, struct hsm_copy *copy, - const struct hsm_action_item *hai) +int llapi_hsm_action_begin(struct hsm_copyaction_private **phcp, + const struct hsm_copytool_private *ct, + const struct hsm_action_item *hai, + int restore_mdt_index, int restore_open_flags, + bool is_error) { - int fd; - int rc; + struct hsm_copyaction_private *hcp; + int rc; - if (memcpy(©->hc_hai, hai, sizeof(*hai)) == NULL) - RETURN(-EFAULT); + hcp = calloc(1, sizeof(*hcp)); + if (hcp == NULL) + return -ENOMEM; - rc = get_root_path(WANT_FD, NULL, &fd, mnt, -1); - if (rc) - return rc; + hcp->data_fd = -1; + hcp->ct_priv = ct; + hcp->copy.hc_hai = *hai; + hcp->copy.hc_hai.hai_len = sizeof(*hai); - rc = ioctl(fd, LL_IOC_HSM_COPY_START, copy); - close(fd); + if (is_error) + goto ok_out; + + if (hai->hai_action == HSMA_RESTORE) { + rc = create_restore_volatile(hcp, restore_mdt_index, + restore_open_flags); + if (rc < 0) + goto err_out; + } + + rc = ioctl(ct->mnt_fd, LL_IOC_HSM_COPY_START, &hcp->copy); + if (rc < 0) { + rc = -errno; + goto err_out; + } + +ok_out: + hcp->magic = CP_PRIV_MAGIC; + *phcp = hcp; + return 0; + +err_out: + if (!(hcp->data_fd < 0)) + close(hcp->data_fd); + + free(hcp); return rc; } -/** +/** Terminate an HSM action processing. * Should be called by copytools just having finished handling the request. - * - * \param mnt Mount point of the corresponding Lustre filesystem. - * \param copy The element used when calling llapi_hsm_copy_start() - * \param hp A hsm_progress structure describing the final state of the - * request. - * - * There is a special case which can be used only when the copytool cannot - * start the copy at all and want to directly return an error. In this case, - * simply fill \a hp structure and set \a copy to NULL. It is useless to call - * llapi_hsm_copy_start() in this case. + * \param hdl[in,out] Handle returned by llapi_hsm_action_start. + * \param he[in] The final range of copied data (for copy actions). + * \param errval[in] The status code of the operation. + * \param flags[in] The flags about the termination status (HP_FLAG_RETRY if + * the error is retryable). * * \return 0 on success. */ -int llapi_hsm_copy_end(char *mnt, struct hsm_copy *copy, - const struct hsm_progress *hp) +int llapi_hsm_action_end(struct hsm_copyaction_private **phcp, + const struct hsm_extent *he, int flags, int errval) { - int end_only = 0; - int fd; - int rc; - - /* llapi_hsm_copy_start() was skipped, so alloc copy. It will - * only be used to give the needed progress information. */ - if (copy == NULL) { - /* This is only ok if there is an error. */ - if (hp->hp_errval == 0) - return -EINVAL; - - copy = (struct hsm_copy *)malloc(sizeof(*copy)); - if (copy == NULL) - return -ENOMEM; - end_only = 1; - copy->hc_hai.hai_cookie = hp->hp_cookie; - copy->hc_hai.hai_fid = hp->hp_fid; - copy->hc_hai.hai_action = HSMA_NONE; + struct hsm_copyaction_private *hcp; + struct hsm_action_item *hai; + int rc; + + if (phcp == NULL || *phcp == NULL || he == NULL) + return -EINVAL; + + hcp = *phcp; + + if (hcp->magic != CP_PRIV_MAGIC) + return -EINVAL; + + hai = &hcp->copy.hc_hai; + + /* 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) + hai->hai_fid = hai->hai_dfid; + + /* Fill the last missing data that will be needed by + * kernel to send a hsm_progress. */ + hcp->copy.hc_flags = flags; + hcp->copy.hc_errval = abs(errval); + + hcp->copy.hc_hai.hai_extent = *he; + + rc = ioctl(hcp->ct_priv->mnt_fd, LL_IOC_HSM_COPY_END, &hcp->copy); + if (rc) { + rc = -errno; + goto err_cleanup; } - /* Fill the last missing data that will be needed by kernel - * to send a hsm_progress. */ - copy->hc_flags = hp->hp_flags; - copy->hc_errval = hp->hp_errval; - /* Update hai if it has changed since start */ - copy->hc_hai.hai_extent = hp->hp_extent; +err_cleanup: + if (!(hcp->data_fd < 0)) + close(hcp->data_fd); - rc = get_root_path(WANT_FD, NULL, &fd, mnt, -1); - if (rc) - goto out_free; + free(hcp); + *phcp = NULL; - rc = ioctl(fd, LL_IOC_HSM_COPY_END, copy); - close(fd); + return rc; +} -out_free: - if (end_only) - free(copy); +/** 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 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) +{ + int rc; + struct hsm_progress hp; + struct hsm_action_item *hai; + + if (hcp == NULL || he == NULL) + return -EINVAL; + + if (hcp->magic != CP_PRIV_MAGIC) + return -EINVAL; + + hai = &hcp->copy.hc_hai; + + memset(&hp, 0, sizeof(hp)); + + hp.hp_cookie = hai->hai_cookie; + hp.hp_flags = hp_flags; + + /* Progress is made on the data fid */ + hp.hp_fid = hai->hai_dfid; + hp.hp_extent = *he; + + rc = ioctl(hcp->ct_priv->mnt_fd, LL_IOC_HSM_PROGRESS, &hp); + if (rc < 0) + rc = -errno; return rc; } +/** Get the fid of object to be used for copying data. + * @return error code if the action is not a copy operation. + */ +int llapi_hsm_action_get_dfid(const struct hsm_copyaction_private *hcp, + lustre_fid *fid) +{ + const struct hsm_action_item *hai = &hcp->copy.hc_hai; + + if (hcp->magic != CP_PRIV_MAGIC) + return -EINVAL; + + if (hai->hai_action != HSMA_RESTORE && hai->hai_action != HSMA_ARCHIVE) + return -EINVAL; + + *fid = hai->hai_dfid; + + return 0; +} + /** - * Copytool progress reporting. + * Get a file descriptor to be used for copying data. It's up to the + * caller to close the FDs obtained from this function. * - * \a hp->hp_errval should be EAGAIN until action is completely finished. - * - * \return 0 on success, an error code otherwise. + * @retval a file descriptor on success. + * @retval a negative error code on failure. */ -int llapi_hsm_progress(char *mnt, struct hsm_progress *hp) +int llapi_hsm_action_get_fd(const struct hsm_copyaction_private *hcp) { - int fd; - int rc; + const struct hsm_action_item *hai = &hcp->copy.hc_hai; - rc = get_root_path(WANT_FD, NULL, &fd, mnt, -1); - if (rc) - return rc; + if (hcp->magic != CP_PRIV_MAGIC) + return -EINVAL; - rc = ioctl(fd, LL_IOC_HSM_PROGRESS, hp); - /* If error, save errno value */ - rc = rc ? -errno : 0; + if (hai->hai_action != HSMA_RESTORE) + return -EINVAL; - close(fd); - return rc; + return dup(hcp->data_fd); } /** @@ -401,54 +592,227 @@ int llapi_hsm_progress(char *mnt, struct hsm_progress *hp) * be used. * \param newfid[out] Filled with new Lustre fid. */ -int llapi_hsm_import(const char *dst, int archive, struct stat *st, +int llapi_hsm_import(const char *dst, int archive, const struct stat *st, unsigned long long stripe_size, int stripe_offset, int stripe_count, int stripe_pattern, char *pool_name, lustre_fid *newfid) { - struct utimbuf time; - int fd; - int rc = 0; + struct hsm_user_import hui; + int fd; + int rc = 0; - /* Create a non-striped file */ - fd = open(dst, O_CREAT | O_EXCL | O_LOV_DELAY_CREATE | O_NONBLOCK, - st->st_mode); + if (stripe_pattern == 0) + stripe_pattern = LOV_PATTERN_RAID0; - if (fd < 0) + /* Create a non-striped file */ + fd = llapi_file_open_pool(dst, O_CREAT | O_WRONLY, st->st_mode, + stripe_size, stripe_offset, stripe_count, + stripe_pattern | LOV_PATTERN_F_RELEASED, + pool_name); + if (fd < 0) { + llapi_error(LLAPI_MSG_ERROR, -errno, + "cannot create '%s' for import", dst); return -errno; - close(fd); - - /* set size on MDT */ - if (truncate(dst, st->st_size) != 0) { - rc = -errno; - goto out_unlink; } - /* Mark archived */ - rc = llapi_hsm_state_set(dst, HS_EXISTS | HS_RELEASED | HS_ARCHIVED, 0, - archive); - if (rc) - goto out_unlink; - /* Get the new fid in the archive. Caller needs to use this fid + /* Get the new fid in Lustre. Caller needs to use this fid from now on. */ - rc = llapi_path2fid(dst, newfid); - if (rc) + rc = llapi_fd2fid(fd, newfid); + if (rc != 0) { + llapi_error(LLAPI_MSG_ERROR, rc, + "cannot get fid of '%s' for import", dst); goto out_unlink; + } - /* Copy the file attributes */ - time.actime = st->st_atime; - time.modtime = st->st_mtime; - if (utime(dst, &time) == -1 || - chmod(dst, st->st_mode) == -1 || - chown(dst, st->st_uid, st->st_gid) == -1) { - /* we might fail here because we change perms/owner */ + hui.hui_uid = st->st_uid; + hui.hui_gid = st->st_gid; + hui.hui_mode = st->st_mode; + hui.hui_size = st->st_size; + hui.hui_archive_id = archive; + hui.hui_atime = st->st_atime; + hui.hui_atime_ns = st->st_atim.tv_nsec; + hui.hui_mtime = st->st_mtime; + hui.hui_mtime_ns = st->st_mtim.tv_nsec; + rc = ioctl(fd, LL_IOC_HSM_IMPORT, &hui); + if (rc != 0) { + llapi_error(LLAPI_MSG_ERROR, rc, "cannot import '%s'", dst); rc = -errno; goto out_unlink; } out_unlink: + if (fd >= 0) + close(fd); if (rc) unlink(dst); return rc; } +/** + * Return the current HSM states and HSM requests related to file pointed by \a + * path. + * + * \param hus Should be allocated by caller. Will be filled with current file + * states. + * + * \retval 0 on success. + * \retval -errno on error. + */ +int llapi_hsm_state_get_fd(int fd, struct hsm_user_state *hus) +{ + int rc; + + rc = ioctl(fd, LL_IOC_HSM_STATE_GET, hus); + /* If error, save errno value */ + rc = rc ? -errno : 0; + + return rc; +} + +/** + * Return the current HSM states and HSM requests related to file pointed by \a + * path. + * + * see llapi_hsm_state_get_fd() for args use and return + */ +int llapi_hsm_state_get(const char *path, struct hsm_user_state *hus) +{ + int fd; + int rc; + + fd = open(path, O_RDONLY | O_NONBLOCK); + if (fd < 0) + return -errno; + + rc = llapi_hsm_state_get_fd(fd, hus); + + close(fd); + return rc; +} + +/** + * Set HSM states of file pointed by \a fd + * + * Using the provided bitmasks, the current HSM states for this file will be + * changed. \a archive_id could be used to change the archive number also. Set + * it to 0 if you do not want to change it. + * + * \param setmask Bitmask for flag to be set. + * \param clearmask Bitmask for flag to be cleared. + * \param archive_id Archive number identifier to use. 0 means no change. + * + * \retval 0 on success. + * \retval -errno on error. + */ +int llapi_hsm_state_set_fd(int fd, __u64 setmask, __u64 clearmask, + __u32 archive_id) +{ + struct hsm_state_set hss; + int rc; + + hss.hss_valid = HSS_SETMASK|HSS_CLEARMASK; + hss.hss_setmask = setmask; + hss.hss_clearmask = clearmask; + /* Change archive_id if provided. We can only change + * to set something different than 0. */ + if (archive_id > 0) { + hss.hss_valid |= HSS_ARCHIVE_ID; + hss.hss_archive_id = archive_id; + } + rc = ioctl(fd, LL_IOC_HSM_STATE_SET, &hss); + /* If error, save errno value */ + rc = rc ? -errno : 0; + + return rc; +} + +/** + * Set HSM states of file pointed by \a path. + * + * see llapi_hsm_state_set_fd() for args use and return + */ +int llapi_hsm_state_set(const char *path, __u64 setmask, __u64 clearmask, + __u32 archive_id) +{ + int fd; + int rc; + + fd = open(path, O_WRONLY | O_LOV_DELAY_CREATE | O_NONBLOCK); + if (fd < 0) + return -errno; + + rc = llapi_hsm_state_set_fd(fd, setmask, clearmask, archive_id); + + close(fd); + return rc; +} + +/** + * Return the current HSM request related to file pointed by \a path. + * + * \param hca Should be allocated by caller. Will be filled with current file + * actions. + * + * \retval 0 on success. + * \retval -errno on error. + */ +int llapi_hsm_current_action(const char *path, struct hsm_current_action *hca) +{ + int fd; + int rc; + + fd = open(path, O_RDONLY | O_NONBLOCK); + if (fd < 0) + return -errno; + + rc = ioctl(fd, LL_IOC_HSM_ACTION, hca); + /* If error, save errno value */ + rc = rc ? -errno : 0; + + close(fd); + return rc; +} + +/** + * Allocate a hsm_user_request with the specified carateristics. + * This structure should be freed with free(). + * + * \return an allocated structure on success, NULL otherwise. + */ +struct hsm_user_request *llapi_hsm_user_request_alloc(int itemcount, + int data_len) +{ + int len = 0; + + len += sizeof(struct hsm_user_request); + len += sizeof(struct hsm_user_item) * itemcount; + len += data_len; + + return (struct hsm_user_request *)malloc(len); +} + +/** + * Send a HSM request to Lustre, described in \param request. + * + * \param path Fullpath to the file to operate on. + * \param request The request, allocated with llapi_hsm_user_request_alloc(). + * + * \return 0 on success, an error code otherwise. + */ +int llapi_hsm_request(const char *path, const struct hsm_user_request *request) +{ + int rc; + int fd; + + rc = get_root_path(WANT_FD, NULL, &fd, (char *)path, -1); + if (rc) + return rc; + + rc = ioctl(fd, LL_IOC_HSM_REQUEST, request); + /* If error, save errno value */ + rc = rc ? -errno : 0; + + close(fd); + return rc; +} +