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