lustre/utils/liblustreapi_hsm.c

   1 /*
   2  * LGPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * (C) Copyright 2012 Commissariat a l'energie atomique et aux energies
   7  *     alternatives
   8  *
   9  * All rights reserved. This program and the accompanying materials
  10  * are made available under the terms of the GNU Lesser General Public License
  11  * (LGPL) version 2.1 or (at your discretion) any later version.
  12  * (LGPL) version 2.1 accompanies this distribution, and is available at
  13  * http://www.gnu.org/licenses/lgpl-2.1.html
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * LGPL HEADER END
  21  */
  22 /*
  23  * lustre/utils/liblustreapi_hsm.c
  24  *
  25  * lustreapi library for hsm calls
  26  *
  27  * Author: Aurelien Degremont <aurelien.degremont@cea.fr>
  28  * Author: JC Lafoucriere <jacques-charles.lafoucriere@cea.fr>
  29  * Author: Thomas Leibovici <thomas.leibovici@cea.fr>
  30  * Author: Henri Doreau <henri.doreau@cea.fr>
  31  */
  32
  33 #include <stdlib.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36 #include <stddef.h>
  37 #include <sys/ioctl.h>
  38 #include <unistd.h>
  39 #include <malloc.h>
  40 #include <errno.h>
  41 #include <dirent.h>
  42 #include <stdarg.h>
  43 #include <sys/stat.h>
  44 #include <sys/types.h>
  45 #include <utime.h>
  46 #include <sys/syscall.h>
  47 #include <fnmatch.h>
  48 #include <glob.h>
  49 #include <signal.h>
  50 #ifdef HAVE_LINUX_UNISTD_H
  51 #include <linux/unistd.h>
  52 #else
  53 #include <unistd.h>
  54 #endif
  55
  56 #include <libcfs/libcfs.h>
  57 #include <lnet/lnetctl.h>
  58 #include <lustre/lustre_idl.h>
  59 #include <lustre/lustreapi.h>
  60 #include "lustreapi_internal.h"
  61
  62 #define OPEN_BY_FID_PATH dot_lustre_name"/fid"
  63
  64 /****** HSM Copytool API ********/
  65 #define CT_PRIV_MAGIC 0xC0BE2001
  66 struct hsm_copytool_private {
  67         int                      magic;
  68         char                    *mnt;
  69         struct kuc_hdr          *kuch;
  70         int                      mnt_fd;
  71         int                      open_by_fid_fd;
  72         lustre_kernelcomm        kuc;
  73         __u32                    archives;
  74 };
  75
  76 #define CP_PRIV_MAGIC 0x19880429
  77 struct hsm_copyaction_private {
  78         __u32                                    magic;
  79         __s32                                    data_fd;
  80         const struct hsm_copytool_private       *ct_priv;
  81         struct hsm_copy                          copy;
  82         struct stat                              stat;
  83 };
  84
  85 #include <libcfs/libcfs.h>
  86
  87 enum ct_progress_type {
  88         CT_START        = 0,
  89         CT_RUNNING      = 50,
  90         CT_FINISH       = 100,
  91         CT_CANCEL       = 150,
  92         CT_ERROR        = 175
  93 };
  94
  95 enum ct_event {
  96         CT_REGISTER             = 1,
  97         CT_UNREGISTER           = 2,
  98         CT_ARCHIVE_START        = HSMA_ARCHIVE,
  99         CT_ARCHIVE_RUNNING      = HSMA_ARCHIVE + CT_RUNNING,
 100         CT_ARCHIVE_FINISH       = HSMA_ARCHIVE + CT_FINISH,
 101         CT_ARCHIVE_CANCEL       = HSMA_ARCHIVE + CT_CANCEL,
 102         CT_ARCHIVE_ERROR        = HSMA_ARCHIVE + CT_ERROR,
 103         CT_RESTORE_START        = HSMA_RESTORE,
 104         CT_RESTORE_RUNNING      = HSMA_RESTORE + CT_RUNNING,
 105         CT_RESTORE_FINISH       = HSMA_RESTORE + CT_FINISH,
 106         CT_RESTORE_CANCEL       = HSMA_RESTORE + CT_CANCEL,
 107         CT_RESTORE_ERROR        = HSMA_RESTORE + CT_ERROR,
 108         CT_REMOVE_START         = HSMA_REMOVE,
 109         CT_REMOVE_RUNNING       = HSMA_REMOVE + CT_RUNNING,
 110         CT_REMOVE_FINISH        = HSMA_REMOVE + CT_FINISH,
 111         CT_REMOVE_CANCEL        = HSMA_REMOVE + CT_CANCEL,
 112         CT_REMOVE_ERROR         = HSMA_REMOVE + CT_ERROR,
 113         CT_EVENT_MAX
 114 };
 115
 116 /* initialized in llapi_hsm_register_event_fifo() */
 117 int llapi_hsm_event_fd = -1;
 118
 119 static inline const char *llapi_hsm_ct_ev2str(int type)
 120 {
 121         switch (type) {
 122         case CT_REGISTER:
 123                 return "REGISTER";
 124         case CT_UNREGISTER:
 125                 return "UNREGISTER";
 126         case CT_ARCHIVE_START:
 127                 return "ARCHIVE_START";
 128         case CT_ARCHIVE_RUNNING:
 129                 return "ARCHIVE_RUNNING";
 130         case CT_ARCHIVE_FINISH:
 131                 return "ARCHIVE_FINISH";
 132         case CT_ARCHIVE_CANCEL:
 133                 return "ARCHIVE_CANCEL";
 134         case CT_ARCHIVE_ERROR:
 135                 return "ARCHIVE_ERROR";
 136         case CT_RESTORE_START:
 137                 return "RESTORE_START";
 138         case CT_RESTORE_RUNNING:
 139                 return "RESTORE_RUNNING";
 140         case CT_RESTORE_FINISH:
 141                 return "RESTORE_FINISH";
 142         case CT_RESTORE_CANCEL:
 143                 return "RESTORE_CANCEL";
 144         case CT_RESTORE_ERROR:
 145                 return "RESTORE_ERROR";
 146         case CT_REMOVE_START:
 147                 return "REMOVE_START";
 148         case CT_REMOVE_RUNNING:
 149                 return "REMOVE_RUNNING";
 150         case CT_REMOVE_FINISH:
 151                 return "REMOVE_FINISH";
 152         case CT_REMOVE_CANCEL:
 153                 return "REMOVE_CANCEL";
 154         case CT_REMOVE_ERROR:
 155                 return "REMOVE_ERROR";
 156         default:
 157                 llapi_err_noerrno(LLAPI_MSG_ERROR,
 158                                   "Unknown event type: %d", type);
 159                 return NULL;
 160         }
 161 }
 162
 163 /**
 164  * Writes a JSON event to the monitor FIFO. Noop if no FIFO has been
 165  * registered.
 166  *
 167  * \param event              A list of llapi_json_items comprising a
 168  *                           single JSON-formatted event.
 169  *
 170  * \retval 0 on success.
 171  * \retval -errno on error.
 172  */
 173 int llapi_hsm_write_json_event(struct llapi_json_item_list **event)
 174 {
 175         int                             rc;
 176         char                            time_string[40];
 177         char                            json_buf[PIPE_BUF];
 178         FILE                            *buf_file;
 179         time_t                          event_time = time(0);
 180         struct tm                       time_components;
 181         struct llapi_json_item_list     *json_items;
 182
 183         /* Noop unless the event fd was initialized */
 184         if (llapi_hsm_event_fd < 0)
 185                 return 0;
 186
 187         if (event == NULL || *event == NULL)
 188                 return -EINVAL;
 189
 190         json_items = *event;
 191
 192         localtime_r(&event_time, &time_components);
 193
 194         if (strftime(time_string, sizeof(time_string), "%Y-%m-%d %T %z",
 195                      &time_components) == 0) {
 196                 rc = -EINVAL;
 197                 llapi_error(LLAPI_MSG_ERROR, rc, "strftime() failed");
 198                 return rc;
 199         }
 200
 201         rc = llapi_json_add_item(&json_items, "event_time", LLAPI_JSON_STRING,
 202                                  time_string);
 203         if (rc < 0) {
 204                 llapi_error(LLAPI_MSG_ERROR, -rc, "error in "
 205                             "llapi_json_add_item()");
 206                 return rc;
 207         }
 208
 209         buf_file = fmemopen(json_buf, sizeof(json_buf), "w");
 210         if (buf_file == NULL)
 211                 return -errno;
 212
 213         rc = llapi_json_write_list(event, buf_file);
 214         if (rc < 0) {
 215                 fclose(buf_file);
 216                 return rc;
 217         }
 218
 219         fclose(buf_file);
 220
 221         if (write(llapi_hsm_event_fd, json_buf, strlen(json_buf)) < 0) {
 222                 /* Ignore write failures due to missing reader. */
 223                 if (errno != EPIPE)
 224                         return -errno;
 225         }
 226
 227         return 0;
 228 }
 229
 230 /**
 231  * Hook for llapi_hsm_copytool_register and llapi_hsm_copytool_unregister
 232  * to generate JSON events suitable for consumption by a copytool
 233  * monitoring process.
 234  *
 235  * \param priv               Opaque private control structure.
 236  * \param event_type         The type of event (register or unregister).
 237  *
 238  * \retval 0 on success.
 239  * \retval -errno on error.
 240  */
 241 int llapi_hsm_log_ct_registration(struct hsm_copytool_private **priv,
 242                                   __u32 event_type)
 243 {
 244         int                             rc;
 245         char                            agent_uuid[UUID_MAX];
 246         struct hsm_copytool_private     *ct;
 247         struct llapi_json_item_list     *json_items;
 248
 249         if (priv == NULL || *priv == NULL)
 250                 return -EINVAL;
 251
 252         ct = *priv;
 253         if (ct->magic != CT_PRIV_MAGIC)
 254                 return -EINVAL;
 255
 256         if (event_type != CT_REGISTER && event_type != CT_UNREGISTER)
 257                 return -EINVAL;
 258
 259         rc = llapi_json_init_list(&json_items);
 260         if (rc < 0)
 261                 goto err;
 262
 263         rc = llapi_get_agent_uuid(ct->mnt, agent_uuid, sizeof(agent_uuid));
 264         if (rc < 0)
 265                 goto err;
 266         llapi_chomp_string(agent_uuid);
 267
 268         rc = llapi_json_add_item(&json_items, "uuid", LLAPI_JSON_STRING,
 269                                  agent_uuid);
 270         if (rc < 0)
 271                 goto err;
 272
 273         rc = llapi_json_add_item(&json_items, "mount_point", LLAPI_JSON_STRING,
 274                                  ct->mnt);
 275         if (rc < 0)
 276                 goto err;
 277
 278         rc = llapi_json_add_item(&json_items, "archive", LLAPI_JSON_INTEGER,
 279                                  &ct->archives);
 280         if (rc < 0)
 281                 goto err;
 282
 283         rc = llapi_json_add_item(&json_items, "event_type", LLAPI_JSON_STRING,
 284                                  (char *)llapi_hsm_ct_ev2str(event_type));
 285         if (rc < 0)
 286                 goto err;
 287
 288         rc = llapi_hsm_write_json_event(&json_items);
 289         if (rc < 0)
 290                 goto err;
 291
 292         goto out_free;
 293
 294 err:
 295         llapi_error(LLAPI_MSG_ERROR, rc, "error in "
 296                     "llapi_hsm_log_ct_registration()");
 297
 298 out_free:
 299         if (json_items != NULL)
 300                 llapi_json_destroy_list(&json_items);
 301
 302         return rc;
 303 }
 304
 305 /**
 306  * Given a copytool progress update, construct a JSON event suitable for
 307  * consumption by a copytool monitoring process.
 308  *
 309  * Examples of various events generated here and written by
 310  * llapi_hsm_write_json_event:
 311  *
 312  * Copytool registration and deregistration:
 313  * {"event_time": "2014-02-26 14:58:01 -0500", "event_type": "REGISTER",
 314  *  "archive": 0, "mount_point": "/mnt/lustre",
 315  *  "uuid": "80379a60-1f8a-743f-daf2-307cde793ec2"}
 316  * {"event_time": "2014-02-26 14:58:01 -0500", "event_type": "UNREGISTER",
 317  *  "archive": 0, "mount_point": "/mnt/lustre",
 318  *  "uuid": "80379a60-1f8a-743f-daf2-307cde793ec2"}
 319  *
 320  * An archive action, start to completion:
 321  * {"event_time": "2014-02-26 14:50:13 -0500", "event_type": "ARCHIVE_START",
 322  *  "total_bytes": 0, "lustre_path": "d71.sanity-hsm/f71.sanity-hsm",
 323  *  "source_fid": "0x2000013a1:0x2:0x0", "data_fid": "0x2000013a1:0x2:0x0"}
 324  * {"event_time": "2014-02-26 14:50:18 -0500", "event_type": "ARCHIVE_RUNNING",
 325  *  "current_bytes": 5242880, "total_bytes": 39000000,
 326  *  "lustre_path": "d71.sanity-hsm/f71.sanity-hsm",
 327  *  "source_fid": "0x2000013a1:0x2:0x0", "data_fid": "0x2000013a1:0x2:0x0"}
 328  * {"event_time": "2014-02-26 14:50:50 -0500", "event_type": "ARCHIVE_FINISH",
 329  *  "source_fid": "0x2000013a1:0x2:0x0", "data_fid": "0x2000013a1:0x2:0x0"}
 330  *
 331  * A log message:
 332  * {"event_time": "2014-02-26 14:50:13 -0500", "event_type": "LOGGED_MESSAGE",
 333  *  "level": "INFO",
 334  *  "message": "lhsmtool_posix[42]: copytool fs=lustre archive#=2 item_count=1"}
 335  *
 336  * \param hcp                Opaque action handle returned by
 337  *                           llapi_hsm_action_start.
 338  * \param hai                The hsm_action_item describing the request.
 339  * \param progress_type      The ct_progress_type describing the update.
 340  * \param total              The total expected bytes for the request.
 341  * \param current            The current copied byte count for the request.
 342  *
 343  * \retval 0 on success.
 344  * \retval -errno on error.
 345  */
 346 int llapi_hsm_log_ct_progress(struct hsm_copyaction_private **phcp,
 347                     const struct hsm_action_item *hai, __u32 progress_type,
 348                     __u64 total, __u64 current)
 349 {
 350         int                             rc;
 351         int                             linkno = 0;
 352         long long                       recno = -1;
 353         char                            lustre_path[PATH_MAX];
 354         char                            strfid[FID_NOBRACE_LEN + 1];
 355         struct hsm_copyaction_private   *hcp;
 356         struct llapi_json_item_list     *json_items;
 357
 358         if (phcp == NULL || *phcp == NULL)
 359                 return -EINVAL;
 360
 361         hcp = *phcp;
 362
 363         rc = llapi_json_init_list(&json_items);
 364         if (rc < 0)
 365                 goto err;
 366
 367         snprintf(strfid, sizeof(strfid), DFID_NOBRACE, PFID(&hai->hai_dfid));
 368         rc = llapi_json_add_item(&json_items, "data_fid",
 369                                  LLAPI_JSON_STRING, strfid);
 370         if (rc < 0)
 371                 goto err;
 372
 373         snprintf(strfid, sizeof(strfid), DFID_NOBRACE, PFID(&hai->hai_fid));
 374         rc = llapi_json_add_item(&json_items, "source_fid",
 375                                  LLAPI_JSON_STRING, strfid);
 376         if (rc < 0)
 377                 goto err;
 378
 379         if (hcp->copy.hc_errval == ECANCELED) {
 380                 progress_type = CT_CANCEL;
 381                 goto cancel;
 382         }
 383
 384         if (hcp->copy.hc_errval != 0) {
 385                 progress_type = CT_ERROR;
 386
 387                 rc = llapi_json_add_item(&json_items, "errno",
 388                                          LLAPI_JSON_INTEGER,
 389                                          &hcp->copy.hc_errval);
 390                 if (rc < 0)
 391                         goto err;
 392
 393                 rc = llapi_json_add_item(&json_items, "error",
 394                                          LLAPI_JSON_STRING,
 395                                          strerror(hcp->copy.hc_errval));
 396                 if (rc < 0)
 397                         goto err;
 398
 399                 goto cancel;
 400         }
 401
 402         /* lustre_path isn't available after a restore completes */
 403         /* total_bytes isn't available after a restore or archive completes */
 404         if (progress_type != CT_FINISH) {
 405                 rc = llapi_fid2path(hcp->ct_priv->mnt, strfid, lustre_path,
 406                                     sizeof(lustre_path), &recno, &linkno);
 407                 if (rc < 0)
 408                         goto err;
 409
 410                 rc = llapi_json_add_item(&json_items, "lustre_path",
 411                                          LLAPI_JSON_STRING, lustre_path);
 412                 if (rc < 0)
 413                         goto err;
 414
 415                 rc = llapi_json_add_item(&json_items, "total_bytes",
 416                                          LLAPI_JSON_BIGNUM, &total);
 417                 if (rc < 0)
 418                         goto err;
 419         }
 420
 421         if (progress_type == CT_RUNNING)
 422                 rc = llapi_json_add_item(&json_items, "current_bytes",
 423                                          LLAPI_JSON_BIGNUM, &current);
 424                 if (rc < 0)
 425                         goto err;
 426
 427 cancel:
 428         rc = llapi_json_add_item(&json_items, "event_type", LLAPI_JSON_STRING,
 429                                  (char *)llapi_hsm_ct_ev2str(hai->hai_action +
 430                                                              progress_type));
 431         if (rc < 0)
 432                 goto err;
 433
 434         rc = llapi_hsm_write_json_event(&json_items);
 435         if (rc < 0)
 436                 goto err;
 437
 438         goto out_free;
 439
 440 err:
 441         llapi_error(LLAPI_MSG_ERROR, rc, "error in "
 442                     "llapi_hsm_log_ct_progress()");
 443
 444 out_free:
 445         if (json_items != NULL)
 446                 llapi_json_destroy_list(&json_items);
 447
 448         return rc;
 449 }
 450
 451 /**
 452  * Given a path to a FIFO, create a filehandle for nonblocking writes to it.
 453  * Intended to be used for copytool monitoring processes that read an
 454  * event stream from the FIFO. Events written in the absence of a reader
 455  * are lost.
 456  *
 457  * \param path               Path to monitor FIFO.
 458  *
 459  * \retval 0 on success.
 460  * \retval -errno on error.
 461  */
 462 int llapi_hsm_register_event_fifo(char *path)
 463 {
 464         int read_fd;
 465         struct stat statbuf;
 466
 467         /* Create the FIFO if necessary. */
 468         if ((mkfifo(path, 0644) < 0) && (errno != EEXIST)) {
 469                 llapi_error(LLAPI_MSG_ERROR, errno, "mkfifo(%s) failed", path);
 470                 return -errno;
 471         }
 472         if (errno == EEXIST) {
 473                 if (stat(path, &statbuf) < 0) {
 474                         llapi_error(LLAPI_MSG_ERROR, errno, "mkfifo(%s) failed",
 475                                     path);
 476                         return -errno;
 477                 }
 478                 if (!S_ISFIFO(statbuf.st_mode) ||
 479                     ((statbuf.st_mode & 0777) != 0644)) {
 480                         llapi_error(LLAPI_MSG_ERROR, errno, "%s exists but is "
 481                                     "not a pipe or has a wrong mode", path);
 482                         return -errno;
 483                 }
 484         }
 485
 486         /* Open the FIFO for read so that the subsequent open for write
 487          * doesn't immediately fail. */
 488         read_fd = open(path, O_RDONLY | O_NONBLOCK);
 489         if (read_fd < 0) {
 490                 llapi_error(LLAPI_MSG_ERROR, errno,
 491                             "cannot open(%s) for read", path);
 492                 return -errno;
 493         }
 494
 495         /* Open the FIFO for writes, but don't block on waiting
 496          * for a reader. */
 497         llapi_hsm_event_fd = open(path, O_WRONLY | O_NONBLOCK);
 498         if (llapi_hsm_event_fd < 0) {
 499                 llapi_error(LLAPI_MSG_ERROR, errno,
 500                             "cannot open(%s) for write", path);
 501                 return -errno;
 502         }
 503
 504         /* Now close the reader. An external monitoring process can
 505          * now open the FIFO for reads. If no reader comes along the
 506          * events are lost. NOTE: Only one reader at a time! */
 507         close(read_fd);
 508
 509         /* Ignore SIGPIPEs -- can occur if the reader goes away. */
 510         signal(SIGPIPE, SIG_IGN);
 511
 512         return 0;
 513 }
 514
 515 /**
 516  * Given a path to a FIFO, close its filehandle and delete the FIFO.
 517  *
 518  * \param path               Path to monitor FIFO.
 519  *
 520  * \retval 0 on success.
 521  * \retval -errno on error.
 522  */
 523 int llapi_hsm_unregister_event_fifo(char *path)
 524 {
 525         /* Noop unless the event fd was initialized */
 526         if (llapi_hsm_event_fd < 0)
 527                 return 0;
 528
 529         if (close(llapi_hsm_event_fd) < 0)
 530                 return -errno;
 531
 532         unlink(path);
 533
 534         llapi_hsm_event_fd = -1;
 535
 536         return 0;
 537 }
 538
 539 /**
 540  * Custom logging callback to be used when a monitoring FIFO has been
 541  * registered. Formats log entries as JSON events suitable for
 542  * consumption by a copytool monitoring process.
 543  *
 544  * \param level              The message loglevel.
 545  * \param _rc                The returncode associated with the message.
 546  * \param fmt                The message format string.
 547  * \param args               Arguments to be formatted by the format string.
 548  *
 549  * \retval None.
 550  */
 551 void llapi_hsm_log_error(enum llapi_message_level level, int _rc,
 552                          const char *fmt, va_list args)
 553 {
 554         int                             rc;
 555         int                             msg_len;
 556         int                             real_level;
 557         char                            *msg = NULL;
 558         va_list                         args2;
 559         struct llapi_json_item_list     *json_items;
 560
 561         /* Noop unless the event fd was initialized */
 562         if (llapi_hsm_event_fd < 0)
 563                 return;
 564
 565         rc = llapi_json_init_list(&json_items);
 566         if (rc < 0)
 567                 goto err;
 568
 569         if ((level & LLAPI_MSG_NO_ERRNO) == 0) {
 570                 rc = llapi_json_add_item(&json_items, "errno",
 571                                          LLAPI_JSON_INTEGER,
 572                                          &_rc);
 573                 if (rc < 0)
 574                         goto err;
 575
 576                 rc = llapi_json_add_item(&json_items, "error",
 577                                          LLAPI_JSON_STRING,
 578                                          strerror(abs(_rc)));
 579                 if (rc < 0)
 580                         goto err;
 581         }
 582
 583         va_copy(args2, args);
 584         msg_len = vsnprintf(NULL, 0, fmt, args2) + 1;
 585         va_end(args2);
 586         if (msg_len >= 0) {
 587                 msg = (char *) alloca(msg_len);
 588                 if (msg == NULL) {
 589                         rc = -ENOMEM;
 590                         goto err;
 591                 }
 592
 593                 rc = vsnprintf(msg, msg_len, fmt, args);
 594                 if (rc < 0)
 595                         goto err;
 596
 597                 rc = llapi_json_add_item(&json_items, "message",
 598                                          LLAPI_JSON_STRING,
 599                                          msg);
 600                 if (rc < 0)
 601                         goto err;
 602         } else {
 603                 rc = llapi_json_add_item(&json_items, "message",
 604                                          LLAPI_JSON_STRING,
 605                                          "INTERNAL ERROR: message failed");
 606                 if (rc < 0)
 607                         goto err;
 608         }
 609
 610         real_level = level & LLAPI_MSG_NO_ERRNO;
 611         real_level = real_level > 0 ? level - LLAPI_MSG_NO_ERRNO : level;
 612
 613         rc = llapi_json_add_item(&json_items, "level", LLAPI_JSON_STRING,
 614                                  (void *)llapi_msg_level2str(real_level));
 615         if (rc < 0)
 616                 goto err;
 617
 618         rc = llapi_json_add_item(&json_items, "event_type", LLAPI_JSON_STRING,
 619                                  "LOGGED_MESSAGE");
 620         if (rc < 0)
 621                 goto err;
 622
 623         rc = llapi_hsm_write_json_event(&json_items);
 624         if (rc < 0)
 625                 goto err;
 626
 627         goto out_free;
 628
 629 err:
 630         /* Write directly to stderr to avoid llapi_error, which now
 631          * emits JSON event messages. */
 632         fprintf(stderr, "\nFATAL ERROR IN llapi_hsm_log_error(): rc %d,", rc);
 633
 634 out_free:
 635         if (json_items != NULL)
 636                 llapi_json_destroy_list(&json_items);
 637
 638         return;
 639 }
 640
 641 /** Register a copytool
 642  * \param[out] priv Opaque private control structure
 643  * \param mnt Lustre filesystem mount point
 644  * \param flags Open flags, currently unused (e.g. O_NONBLOCK)
 645  * \param archive_count
 646  * \param archives Which archive numbers this copytool is responsible for
 647  */
 648 int llapi_hsm_copytool_register(struct hsm_copytool_private **priv,
 649                                 const char *mnt, int flags, int archive_count,
 650                                 int *archives)
 651 {
 652         struct hsm_copytool_private     *ct;
 653         int                              rc;
 654
 655         if (archive_count > 0 && archives == NULL) {
 656                 llapi_err_noerrno(LLAPI_MSG_ERROR,
 657                                   "NULL archive numbers");
 658                 return -EINVAL;
 659         }
 660
 661         ct = calloc(1, sizeof(*ct));
 662         if (ct == NULL)
 663                 return -ENOMEM;
 664
 665         ct->magic = CT_PRIV_MAGIC;
 666         ct->mnt_fd = -1;
 667         ct->open_by_fid_fd = -1;
 668         ct->kuc.lk_rfd = LK_NOFD;
 669         ct->kuc.lk_wfd = LK_NOFD;
 670
 671         ct->mnt = strdup(mnt);
 672         if (ct->mnt == NULL) {
 673                 rc = -ENOMEM;
 674                 goto out_err;
 675         }
 676
 677         ct->kuch = malloc(HAL_MAXSIZE + sizeof(*ct->kuch));
 678         if (ct->kuch == NULL) {
 679                 rc = -ENOMEM;
 680                 goto out_err;
 681         }
 682
 683         ct->mnt_fd = open(ct->mnt, O_RDONLY);
 684         if (ct->mnt_fd < 0) {
 685                 rc = -errno;
 686                 goto out_err;
 687         }
 688
 689         ct->open_by_fid_fd = openat(ct->mnt_fd, OPEN_BY_FID_PATH, O_RDONLY);
 690         if (ct->open_by_fid_fd < 0) {
 691                 rc = -errno;
 692                 goto out_err;
 693         }
 694
 695         /* no archives specified means "match all". */
 696         ct->archives = 0;
 697         for (rc = 0; rc < archive_count; rc++) {
 698                 if (archives[rc] > 8 * sizeof(ct->archives)) {
 699                         llapi_err_noerrno(LLAPI_MSG_ERROR,
 700                                           "maximum of %zu archives supported",
 701                                           8 * sizeof(ct->archives));
 702                         goto out_err;
 703                 }
 704                 /* in the list we have a all archive wildcard
 705                  * so move to all archives mode
 706                  */
 707                 if (archives[rc] == 0) {
 708                         ct->archives = 0;
 709                         archive_count = 0;
 710                         break;
 711                 }
 712                 ct->archives |= (1 << (archives[rc] - 1));
 713         }
 714
 715         rc = libcfs_ukuc_start(&ct->kuc, KUC_GRP_HSM);
 716         if (rc < 0)
 717                 goto out_err;
 718
 719         /* Storing archive(s) in lk_data; see mdc_ioc_hsm_ct_start */
 720         ct->kuc.lk_data = ct->archives;
 721         rc = ioctl(ct->mnt_fd, LL_IOC_HSM_CT_START, &ct->kuc);
 722         if (rc < 0) {
 723                 rc = -errno;
 724                 llapi_error(LLAPI_MSG_ERROR, rc,
 725                             "cannot start copytool on '%s'", mnt);
 726                 goto out_err;
 727         } else {
 728                 rc = 0;
 729         }
 730
 731         llapi_hsm_log_ct_registration(&ct, CT_REGISTER);
 732
 733         /* Only the kernel reference keeps the write side open */
 734         close(ct->kuc.lk_wfd);
 735         ct->kuc.lk_wfd = LK_NOFD;
 736         if (rc < 0)
 737                 goto out_kuc;
 738
 739         *priv = ct;
 740         return 0;
 741
 742 out_kuc:
 743         /* cleanup the kuc channel */
 744         libcfs_ukuc_stop(&ct->kuc);
 745
 746 out_err:
 747         if (!(ct->mnt_fd < 0))
 748                 close(ct->mnt_fd);
 749
 750         if (!(ct->open_by_fid_fd < 0))
 751                 close(ct->open_by_fid_fd);
 752
 753         free(ct->mnt);
 754
 755         free(ct->kuch);
 756
 757         free(ct);
 758
 759         return rc;
 760 }
 761
 762 /** Deregister a copytool
 763  * Note: under Linux, until llapi_hsm_copytool_unregister is called
 764  * (or the program is killed), the libcfs module will be referenced
 765  * and unremovable, even after Lustre services stop.
 766  */
 767 int llapi_hsm_copytool_unregister(struct hsm_copytool_private **priv)
 768 {
 769         struct hsm_copytool_private *ct;
 770
 771         if (priv == NULL || *priv == NULL)
 772                 return -EINVAL;
 773
 774         ct = *priv;
 775         if (ct->magic != CT_PRIV_MAGIC)
 776                 return -EINVAL;
 777
 778         /* Tell the kernel to stop sending us messages */
 779         ct->kuc.lk_flags = LK_FLG_STOP;
 780         ioctl(ct->mnt_fd, LL_IOC_HSM_CT_START, &ct->kuc);
 781
 782         /* Shut down the kernelcomms */
 783         libcfs_ukuc_stop(&ct->kuc);
 784
 785         llapi_hsm_log_ct_registration(&ct, CT_UNREGISTER);
 786
 787         close(ct->open_by_fid_fd);
 788         close(ct->mnt_fd);
 789         free(ct->mnt);
 790         free(ct->kuch);
 791         free(ct);
 792         *priv = NULL;
 793
 794         return 0;
 795 }
 796
 797 /** Wait for the next hsm_action_list
 798  * \param ct Opaque private control structure
 799  * \param halh Action list handle, will be allocated here
 800  * \param msgsize Number of bytes in the message, will be set here
 801  * \return 0 valid message received; halh and msgsize are set
 802  *         <0 error code
 803  * Note: The application must not call llapi_hsm_copytool_recv until it has
 804  * cleared the data in ct->kuch from the previous call.
 805  */
 806 int llapi_hsm_copytool_recv(struct hsm_copytool_private *ct,
 807                             struct hsm_action_list **halh, int *msgsize)
 808 {
 809         struct kuc_hdr          *kuch;
 810         struct hsm_action_list  *hal;
 811         int                      rc = 0;
 812
 813         if (ct == NULL || ct->magic != CT_PRIV_MAGIC)
 814                 return -EINVAL;
 815
 816         if (halh == NULL || msgsize == NULL)
 817                 return -EINVAL;
 818
 819         kuch = ct->kuch;
 820
 821         rc = libcfs_ukuc_msg_get(&ct->kuc, (char *)kuch,
 822                                  HAL_MAXSIZE + sizeof(*kuch),
 823                                  KUC_TRANSPORT_HSM);
 824         if (rc < 0)
 825                 goto out_err;
 826
 827         /* Handle generic messages */
 828         if (kuch->kuc_transport == KUC_TRANSPORT_GENERIC &&
 829             kuch->kuc_msgtype == KUC_MSG_SHUTDOWN) {
 830                 rc = -ESHUTDOWN;
 831                 goto out_err;
 832         }
 833
 834         if (kuch->kuc_transport != KUC_TRANSPORT_HSM ||
 835             kuch->kuc_msgtype != HMT_ACTION_LIST) {
 836                 llapi_err_noerrno(LLAPI_MSG_ERROR,
 837                                   "Unknown HSM message type %d:%d\n",
 838                                   kuch->kuc_transport, kuch->kuc_msgtype);
 839                 rc = -EPROTO;
 840                 goto out_err;
 841         }
 842
 843         if (kuch->kuc_msglen < sizeof(*kuch) + sizeof(*hal)) {
 844                 llapi_err_noerrno(LLAPI_MSG_ERROR, "Short HSM message %d",
 845                                   kuch->kuc_msglen);
 846                 rc = -EPROTO;
 847                 goto out_err;
 848         }
 849
 850         /* Our message is a hsm_action_list. Use pointer math to skip
 851         * kuch_hdr and point directly to the message payload.
 852         */
 853         hal = (struct hsm_action_list *)(kuch + 1);
 854
 855         /* Check that we have registered for this archive #
 856          * if 0 registered, we serve any archive */
 857         if (ct->archives &&
 858             ((1 << (hal->hal_archive_id - 1)) & ct->archives) == 0) {
 859                 llapi_err_noerrno(LLAPI_MSG_INFO,
 860                                   "This copytool does not service archive #%d,"
 861                                   " ignoring this request."
 862                                   " Mask of served archive is 0x%.8X",
 863                                   hal->hal_archive_id, ct->archives);
 864                 rc = -EAGAIN;
 865
 866                 goto out_err;
 867         }
 868
 869         *halh = hal;
 870         *msgsize = kuch->kuc_msglen - sizeof(*kuch);
 871         return 0;
 872
 873 out_err:
 874         *halh = NULL;
 875         *msgsize = 0;
 876         return rc;
 877 }
 878
 879 /** Get parent path from mount point and fid.
 880  *
 881  * \param mnt        Filesystem root path.
 882  * \param fid        Object FID.
 883  * \param parent     Destination buffer.
 884  * \param parent_len Destination buffer size.
 885  * \return 0 on success.
 886  */
 887 static int fid_parent(const char *mnt, const lustre_fid *fid, char *parent,
 888                       size_t parent_len)
 889 {
 890         int              rc;
 891         int              linkno = 0;
 892         long long        recno = -1;
 893         char             file[PATH_MAX];
 894         char             strfid[FID_NOBRACE_LEN + 1];
 895         char            *ptr;
 896
 897         snprintf(strfid, sizeof(strfid), DFID_NOBRACE, PFID(fid));
 898
 899         rc = llapi_fid2path(mnt, strfid, file, sizeof(file),
 900                             &recno, &linkno);
 901         if (rc < 0)
 902                 return rc;
 903
 904         /* fid2path returns a relative path */
 905         rc = snprintf(parent, parent_len, "%s/%s", mnt, file);
 906         if (rc >= parent_len)
 907                 return -ENAMETOOLONG;
 908
 909         /* remove file name */
 910         ptr = strrchr(parent, '/');
 911         if (ptr == NULL || ptr == parent) {
 912                 rc = -EINVAL;
 913         } else {
 914                 *ptr = '\0';
 915                 rc = 0;
 916         }
 917
 918         return rc;
 919 }
 920
 921 static int ct_open_by_fid(const struct hsm_copytool_private *ct,
 922                           const struct lu_fid *fid, int open_flags)
 923 {
 924         char fid_name[FID_NOBRACE_LEN + 1];
 925
 926         snprintf(fid_name, sizeof(fid_name), DFID_NOBRACE, PFID(fid));
 927
 928         return openat(ct->open_by_fid_fd, fid_name, open_flags);
 929 }
 930
 931 static int ct_stat_by_fid(const struct hsm_copytool_private *ct,
 932                           const struct lu_fid *fid,
 933                           struct stat *buf)
 934 {
 935         char fid_name[FID_NOBRACE_LEN + 1];
 936
 937         snprintf(fid_name, sizeof(fid_name), DFID_NOBRACE, PFID(fid));
 938
 939         return fstatat(ct->open_by_fid_fd, fid_name, buf, 0);
 940 }
 941
 942 /** Create the destination volatile file for a restore operation.
 943  *
 944  * \param hcp        Private copyaction handle.
 945  * \param mdt_index  MDT index where to create the volatile file.
 946  * \param flags      Volatile file creation flags.
 947  * \return 0 on success.
 948  */
 949 static int create_restore_volatile(struct hsm_copyaction_private *hcp,
 950                                    int mdt_index, int open_flags)
 951 {
 952         int                      rc;
 953         int                      fd;
 954         char                     parent[PATH_MAX + 1];
 955         const char              *mnt = hcp->ct_priv->mnt;
 956         struct hsm_action_item  *hai = &hcp->copy.hc_hai;
 957
 958         rc = fid_parent(mnt, &hai->hai_fid, parent, sizeof(parent));
 959         if (rc < 0) {
 960                 /* fid_parent() failed, try to keep on going */
 961                 llapi_error(LLAPI_MSG_ERROR, rc,
 962                             "cannot get parent path to restore "DFID" "
 963                             "using '%s'", PFID(&hai->hai_fid), mnt);
 964                 snprintf(parent, sizeof(parent), "%s", mnt);
 965         }
 966
 967         fd = llapi_create_volatile_idx(parent, mdt_index, open_flags);
 968         if (fd < 0)
 969                 return fd;
 970
 971         rc = fchown(fd, hcp->stat.st_uid, hcp->stat.st_gid);
 972         if (rc < 0)
 973                 goto err_cleanup;
 974
 975         rc = llapi_fd2fid(fd, &hai->hai_dfid);
 976         if (rc < 0)
 977                 goto err_cleanup;
 978
 979         hcp->data_fd = fd;
 980
 981         return 0;
 982
 983 err_cleanup:
 984         hcp->data_fd = -1;
 985         close(fd);
 986
 987         return rc;
 988 }
 989
 990 /** Start processing an HSM action.
 991  * Should be called by copytools just before starting handling a request.
 992  * It could be skipped if copytool only want to directly report an error,
 993  * \see llapi_hsm_action_end().
 994  *
 995  * \param hcp                Opaque action handle to be passed to
 996  *                           llapi_hsm_action_progress and llapi_hsm_action_end.
 997  * \param ct                 Copytool handle acquired at registration.
 998  * \param hai                The hsm_action_item describing the request.
 999  * \param restore_mdt_index  On restore: MDT index where to create the volatile
1000  *                           file. Use -1 for default.
1001  * \param restore_open_flags On restore: volatile file creation mode. Use
1002  *                           O_LOV_DELAY_CREATE to manually set the LOVEA
1003  *                           afterwards.
1004  * \param is_error           Whether this call is just to report an error.
1005  *
1006  * \return 0 on success.
1007  */
1008 int llapi_hsm_action_begin(struct hsm_copyaction_private **phcp,
1009                            const struct hsm_copytool_private *ct,
1010                            const struct hsm_action_item *hai,
1011                            int restore_mdt_index, int restore_open_flags,
1012                            bool is_error)
1013 {
1014         struct hsm_copyaction_private   *hcp;
1015         int                              rc;
1016
1017         hcp = calloc(1, sizeof(*hcp));
1018         if (hcp == NULL)
1019                 return -ENOMEM;
1020
1021         hcp->data_fd = -1;
1022         hcp->ct_priv = ct;
1023         hcp->copy.hc_hai = *hai;
1024         hcp->copy.hc_hai.hai_len = sizeof(*hai);
1025
1026         if (is_error)
1027                 goto ok_out;
1028
1029         if (hai->hai_action == HSMA_RESTORE) {
1030                 rc = ct_stat_by_fid(hcp->ct_priv, &hai->hai_fid, &hcp->stat);
1031                 if (rc < 0)
1032                         goto err_out;
1033
1034                 rc = create_restore_volatile(hcp, restore_mdt_index,
1035                                              restore_open_flags);
1036                 if (rc < 0)
1037                         goto err_out;
1038         }
1039
1040         rc = ioctl(ct->mnt_fd, LL_IOC_HSM_COPY_START, &hcp->copy);
1041         if (rc < 0) {
1042                 rc = -errno;
1043                 goto err_out;
1044         }
1045
1046         llapi_hsm_log_ct_progress(&hcp, hai, CT_START, 0, 0);
1047
1048 ok_out:
1049         hcp->magic = CP_PRIV_MAGIC;
1050         *phcp = hcp;
1051         return 0;
1052
1053 err_out:
1054         if (!(hcp->data_fd < 0))
1055                 close(hcp->data_fd);
1056
1057         free(hcp);
1058
1059         return rc;
1060 }
1061
1062 /** Terminate an HSM action processing.
1063  * Should be called by copytools just having finished handling the request.
1064  * \param hdl[in,out]  Handle returned by llapi_hsm_action_start.
1065  * \param he[in]       The final range of copied data (for copy actions).
1066  * \param errval[in]   The status code of the operation.
1067  * \param flags[in]    The flags about the termination status (HP_FLAG_RETRY if
1068  *                     the error is retryable).
1069  *
1070  * \return 0 on success.
1071  */
1072 int llapi_hsm_action_end(struct hsm_copyaction_private **phcp,
1073                          const struct hsm_extent *he, int hp_flags, int errval)
1074 {
1075         struct hsm_copyaction_private   *hcp;
1076         struct hsm_action_item          *hai;
1077         int                              rc;
1078
1079         if (phcp == NULL || *phcp == NULL || he == NULL)
1080                 return -EINVAL;
1081
1082         hcp = *phcp;
1083
1084         if (hcp->magic != CP_PRIV_MAGIC)
1085                 return -EINVAL;
1086
1087         hai = &hcp->copy.hc_hai;
1088
1089         if (hai->hai_action == HSMA_RESTORE && errval == 0) {
1090                 struct timeval tv[2];
1091
1092                 /* Set {a,m}time of volatile file to that of original. */
1093                 tv[0].tv_sec = hcp->stat.st_atime;
1094                 tv[0].tv_usec = 0;
1095                 tv[1].tv_sec = hcp->stat.st_mtime;
1096                 tv[1].tv_usec = 0;
1097                 if (futimes(hcp->data_fd, tv) < 0) {
1098                         errval = -errno;
1099                         goto end;
1100                 }
1101
1102                 rc = fsync(hcp->data_fd);
1103                 if (rc < 0) {
1104                         errval = -errno;
1105                         goto end;
1106                 }
1107         }
1108
1109 end:
1110         /* In some cases, like restore, 2 FIDs are used.
1111          * Set the right FID to use here. */
1112         if (hai->hai_action == HSMA_ARCHIVE || hai->hai_action == HSMA_RESTORE)
1113                 hai->hai_fid = hai->hai_dfid;
1114
1115         /* Fill the last missing data that will be needed by
1116          * kernel to send a hsm_progress. */
1117         hcp->copy.hc_flags  = hp_flags;
1118         hcp->copy.hc_errval = abs(errval);
1119
1120         hcp->copy.hc_hai.hai_extent = *he;
1121
1122         rc = ioctl(hcp->ct_priv->mnt_fd, LL_IOC_HSM_COPY_END, &hcp->copy);
1123         if (rc) {
1124                 rc = -errno;
1125                 goto err_cleanup;
1126         }
1127
1128         llapi_hsm_log_ct_progress(&hcp, hai, CT_FINISH, 0, 0);
1129
1130 err_cleanup:
1131         if (!(hcp->data_fd < 0))
1132                 close(hcp->data_fd);
1133
1134         free(hcp);
1135         *phcp = NULL;
1136
1137         return rc;
1138 }
1139
1140 /** Notify a progress in processing an HSM action.
1141  * \param hdl[in,out]   handle returned by llapi_hsm_action_start.
1142  * \param he[in]        the range of copied data (for copy actions).
1143  * \param total[in]     the expected total of copied data (for copy actions).
1144  * \param hp_flags[in]  HSM progress flags.
1145  * \return 0 on success.
1146  */
1147 int llapi_hsm_action_progress(struct hsm_copyaction_private *hcp,
1148                               const struct hsm_extent *he, __u64 total,
1149                               int hp_flags)
1150 {
1151         int                      rc;
1152         struct hsm_progress      hp;
1153         struct hsm_action_item  *hai;
1154
1155         if (hcp == NULL || he == NULL)
1156                 return -EINVAL;
1157
1158         if (hcp->magic != CP_PRIV_MAGIC)
1159                 return -EINVAL;
1160
1161         hai = &hcp->copy.hc_hai;
1162
1163         memset(&hp, 0, sizeof(hp));
1164
1165         hp.hp_cookie = hai->hai_cookie;
1166         hp.hp_flags  = hp_flags;
1167
1168         /* Progress is made on the data fid */
1169         hp.hp_fid = hai->hai_dfid;
1170         hp.hp_extent = *he;
1171
1172         rc = ioctl(hcp->ct_priv->mnt_fd, LL_IOC_HSM_PROGRESS, &hp);
1173         if (rc < 0)
1174                 rc = -errno;
1175
1176         llapi_hsm_log_ct_progress(&hcp, hai, CT_RUNNING, total, he->length);
1177
1178         return rc;
1179 }
1180
1181 /** Get the fid of object to be used for copying data.
1182  * @return error code if the action is not a copy operation.
1183  */
1184 int llapi_hsm_action_get_dfid(const struct hsm_copyaction_private *hcp,
1185                               lustre_fid *fid)
1186 {
1187         const struct hsm_action_item    *hai = &hcp->copy.hc_hai;
1188
1189         if (hcp->magic != CP_PRIV_MAGIC)
1190                 return -EINVAL;
1191
1192         if (hai->hai_action != HSMA_RESTORE && hai->hai_action != HSMA_ARCHIVE)
1193                 return -EINVAL;
1194
1195         *fid = hai->hai_dfid;
1196
1197         return 0;
1198 }
1199
1200 /**
1201  * Get a file descriptor to be used for copying data. It's up to the
1202  * caller to close the FDs obtained from this function.
1203  *
1204  * @retval a file descriptor on success.
1205  * @retval a negative error code on failure.
1206  */
1207 int llapi_hsm_action_get_fd(const struct hsm_copyaction_private *hcp)
1208 {
1209         const struct hsm_action_item    *hai = &hcp->copy.hc_hai;
1210
1211         if (hcp->magic != CP_PRIV_MAGIC)
1212                 return -EINVAL;
1213
1214         if (hai->hai_action == HSMA_ARCHIVE)
1215                 return ct_open_by_fid(hcp->ct_priv, &hai->hai_dfid,
1216                                 O_RDONLY | O_NOATIME | O_NOFOLLOW | O_NONBLOCK);
1217         else if (hai->hai_action == HSMA_RESTORE)
1218                 return dup(hcp->data_fd);
1219         else
1220                 return -EINVAL;
1221 }
1222
1223 /**
1224  * Import an existing hsm-archived file into Lustre.
1225  *
1226  * Caller must access file by (returned) newfid value from now on.
1227  *
1228  * \param dst      path to Lustre destination (e.g. /mnt/lustre/my/file).
1229  * \param archive  archive number.
1230  * \param st       struct stat buffer containing file ownership, perm, etc.
1231  * \param stripe_* Striping options.  Currently ignored, since the restore
1232  *                 operation will set the striping.  In V2, this striping might
1233  *                 be used.
1234  * \param newfid[out] Filled with new Lustre fid.
1235  */
1236 int llapi_hsm_import(const char *dst, int archive, const struct stat *st,
1237                      unsigned long long stripe_size, int stripe_offset,
1238                      int stripe_count, int stripe_pattern, char *pool_name,
1239                      lustre_fid *newfid)
1240 {
1241         struct hsm_user_import   hui;
1242         int                      fd;
1243         int                      rc = 0;
1244
1245         if (stripe_pattern == 0)
1246                 stripe_pattern = LOV_PATTERN_RAID0;
1247
1248         /* Create a non-striped file */
1249         fd = llapi_file_open_pool(dst, O_CREAT | O_WRONLY, st->st_mode,
1250                                   stripe_size, stripe_offset, stripe_count,
1251                                   stripe_pattern | LOV_PATTERN_F_RELEASED,
1252                                   pool_name);
1253         if (fd < 0) {
1254                 llapi_error(LLAPI_MSG_ERROR, -errno,
1255                             "cannot create '%s' for import", dst);
1256                 return -errno;
1257         }
1258
1259         /* Get the new fid in Lustre. Caller needs to use this fid
1260            from now on. */
1261         rc = llapi_fd2fid(fd, newfid);
1262         if (rc != 0) {
1263                 llapi_error(LLAPI_MSG_ERROR, rc,
1264                             "cannot get fid of '%s' for import", dst);
1265                 goto out_unlink;
1266         }
1267
1268         hui.hui_uid = st->st_uid;
1269         hui.hui_gid = st->st_gid;
1270         hui.hui_mode = st->st_mode;
1271         hui.hui_size = st->st_size;
1272         hui.hui_archive_id = archive;
1273         hui.hui_atime = st->st_atime;
1274         hui.hui_atime_ns = st->st_atim.tv_nsec;
1275         hui.hui_mtime = st->st_mtime;
1276         hui.hui_mtime_ns = st->st_mtim.tv_nsec;
1277         rc = ioctl(fd, LL_IOC_HSM_IMPORT, &hui);
1278         if (rc != 0) {
1279                 llapi_error(LLAPI_MSG_ERROR, rc, "cannot import '%s'", dst);
1280                 rc = -errno;
1281                 goto out_unlink;
1282         }
1283
1284 out_unlink:
1285         if (fd >= 0)
1286                 close(fd);
1287         if (rc)
1288                 unlink(dst);
1289         return rc;
1290 }
1291
1292 /**
1293  * Return the current HSM states and HSM requests related to file pointed by \a
1294  * path.
1295  *
1296  * \param hus  Should be allocated by caller. Will be filled with current file
1297  *             states.
1298  *
1299  * \retval 0 on success.
1300  * \retval -errno on error.
1301  */
1302 int llapi_hsm_state_get_fd(int fd, struct hsm_user_state *hus)
1303 {
1304         int rc;
1305
1306         rc = ioctl(fd, LL_IOC_HSM_STATE_GET, hus);
1307         /* If error, save errno value */
1308         rc = rc ? -errno : 0;
1309
1310         return rc;
1311 }
1312
1313 /**
1314  * Return the current HSM states and HSM requests related to file pointed by \a
1315  * path.
1316  *
1317  * see llapi_hsm_state_get_fd() for args use and return
1318  */
1319 int llapi_hsm_state_get(const char *path, struct hsm_user_state *hus)
1320 {
1321         int fd;
1322         int rc;
1323
1324         fd = open(path, O_RDONLY | O_NONBLOCK);
1325         if (fd < 0)
1326                 return -errno;
1327
1328         rc = llapi_hsm_state_get_fd(fd, hus);
1329
1330         close(fd);
1331         return rc;
1332 }
1333
1334 /**
1335  * Set HSM states of file pointed by \a fd
1336  *
1337  * Using the provided bitmasks, the current HSM states for this file will be
1338  * changed. \a archive_id could be used to change the archive number also. Set
1339  * it to 0 if you do not want to change it.
1340  *
1341  * \param setmask      Bitmask for flag to be set.
1342  * \param clearmask    Bitmask for flag to be cleared.
1343  * \param archive_id  Archive number identifier to use. 0 means no change.
1344  *
1345  * \retval 0 on success.
1346  * \retval -errno on error.
1347  */
1348 int llapi_hsm_state_set_fd(int fd, __u64 setmask, __u64 clearmask,
1349                            __u32 archive_id)
1350 {
1351         struct hsm_state_set     hss;
1352         int                      rc;
1353
1354         hss.hss_valid = HSS_SETMASK|HSS_CLEARMASK;
1355         hss.hss_setmask = setmask;
1356         hss.hss_clearmask = clearmask;
1357         /* Change archive_id if provided. We can only change
1358          * to set something different than 0. */
1359         if (archive_id > 0) {
1360                 hss.hss_valid |= HSS_ARCHIVE_ID;
1361                 hss.hss_archive_id = archive_id;
1362         }
1363         rc = ioctl(fd, LL_IOC_HSM_STATE_SET, &hss);
1364         /* If error, save errno value */
1365         rc = rc ? -errno : 0;
1366
1367         return rc;
1368 }
1369
1370 /**
1371  * Set HSM states of file pointed by \a path.
1372  *
1373  * see llapi_hsm_state_set_fd() for args use and return
1374  */
1375 int llapi_hsm_state_set(const char *path, __u64 setmask, __u64 clearmask,
1376                         __u32 archive_id)
1377 {
1378         int fd;
1379         int rc;
1380
1381         fd = open(path, O_WRONLY | O_LOV_DELAY_CREATE | O_NONBLOCK);
1382         if (fd < 0)
1383                 return -errno;
1384
1385         rc = llapi_hsm_state_set_fd(fd, setmask, clearmask, archive_id);
1386
1387         close(fd);
1388         return rc;
1389 }
1390
1391 /**
1392  * Return the current HSM request related to file pointed by \a path.
1393  *
1394  * \param hca  Should be allocated by caller. Will be filled with current file
1395  *             actions.
1396  *
1397  * \retval 0 on success.
1398  * \retval -errno on error.
1399  */
1400 int llapi_hsm_current_action(const char *path, struct hsm_current_action *hca)
1401 {
1402         int fd;
1403         int rc;
1404
1405         fd = open(path, O_RDONLY | O_NONBLOCK);
1406         if (fd < 0)
1407                 return -errno;
1408
1409         rc = ioctl(fd, LL_IOC_HSM_ACTION, hca);
1410         /* If error, save errno value */
1411         rc = rc ? -errno : 0;
1412
1413         close(fd);
1414         return rc;
1415 }
1416
1417 /**
1418  * Allocate a hsm_user_request with the specified carateristics.
1419  * This structure should be freed with free().
1420  *
1421  * \return an allocated structure on success, NULL otherwise.
1422  */
1423 struct hsm_user_request *llapi_hsm_user_request_alloc(int itemcount,
1424                                                       int data_len)
1425 {
1426         int len = 0;
1427
1428         len += sizeof(struct hsm_user_request);
1429         len += sizeof(struct hsm_user_item) * itemcount;
1430         len += data_len;
1431
1432         return (struct hsm_user_request *)malloc(len);
1433 }
1434
1435 /**
1436  * Send a HSM request to Lustre, described in \param request.
1437  *
1438  * \param path    Fullpath to the file to operate on.
1439  * \param request The request, allocated with llapi_hsm_user_request_alloc().
1440  *
1441  * \return 0 on success, an error code otherwise.
1442  */
1443 int llapi_hsm_request(const char *path, const struct hsm_user_request *request)
1444 {
1445         int rc;
1446         int fd;
1447
1448         rc = get_root_path(WANT_FD, NULL, &fd, (char *)path, -1);
1449         if (rc)
1450                 return rc;
1451
1452         rc = ioctl(fd, LL_IOC_HSM_REQUEST, request);
1453         /* If error, save errno value */
1454         rc = rc ? -errno : 0;
1455
1456         close(fd);
1457         return rc;
1458 }
1459