Whamcloud - gitweb
LU-3365 lmv: support DNE with HSM.
[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  * 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  */
31
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <stddef.h>
36 #include <sys/ioctl.h>
37 #include <unistd.h>
38 #include <malloc.h>
39 #include <errno.h>
40 #include <dirent.h>
41 #include <stdarg.h>
42 #include <sys/stat.h>
43 #include <sys/types.h>
44 #include <utime.h>
45 #include <sys/syscall.h>
46 #include <fnmatch.h>
47 #include <glob.h>
48 #ifdef HAVE_LINUX_UNISTD_H
49 #include <linux/unistd.h>
50 #else
51 #include <unistd.h>
52 #endif
53
54 #include <liblustre.h>
55 #include <lnet/lnetctl.h>
56 #include <obd.h>
57 #include <obd_lov.h>
58 #include <lustre/lustreapi.h>
59 #include "lustreapi_internal.h"
60
61 /****** HSM Copytool API ********/
62 #define CT_PRIV_MAGIC 0xC0BE2001
63 struct hsm_copytool_private {
64         int                      magic;
65         char                    *fsname;
66         lustre_kernelcomm        kuc;
67         __u32                    archives;
68 };
69
70 #include <libcfs/libcfs.h>
71
72 /** Register a copytool
73  * \param[out] priv Opaque private control structure
74  * \param fsname Lustre filesystem
75  * \param flags Open flags, currently unused (e.g. O_NONBLOCK)
76  * \param archive_count
77  * \param archives Which archive numbers this copytool is responsible for
78  */
79 int llapi_hsm_copytool_start(struct hsm_copytool_private **priv, char *fsname,
80                              int flags, int archive_count, int *archives)
81 {
82         struct hsm_copytool_private     *ct;
83         int                              rc;
84
85         if (archive_count > 0 && archives == NULL) {
86                 llapi_err_noerrno(LLAPI_MSG_ERROR,
87                                   "NULL archive numbers");
88                 return -EINVAL;
89         }
90
91         ct = calloc(1, sizeof(*ct));
92         if (ct == NULL)
93                 return -ENOMEM;
94
95         ct->fsname = malloc(strlen(fsname) + 1);
96         if (ct->fsname == NULL) {
97                 rc = -ENOMEM;
98                 goto out_err;
99         }
100         strcpy(ct->fsname, fsname);
101         ct->magic = CT_PRIV_MAGIC;
102
103         /* no archives specified means "match all". */
104         ct->archives = 0;
105         for (rc = 0; rc < archive_count; rc++) {
106                 if (archives[rc] > 8 * sizeof(ct->archives)) {
107                         llapi_err_noerrno(LLAPI_MSG_ERROR,
108                                           "Maximum of %d archives supported",
109                                           8 * sizeof(ct->archives));
110                         goto out_err;
111                 }
112                 /* in the list we have a all archive wildcard
113                  * so move to all archives mode
114                  */
115                 if (archives[rc] == 0) {
116                         ct->archives = 0;
117                         archive_count = 0;
118                         break;
119                 }
120                 ct->archives |= (1 << (archives[rc] - 1));
121         }
122
123         rc = libcfs_ukuc_start(&ct->kuc, KUC_GRP_HSM);
124         if (rc < 0)
125                 goto out_err;
126
127         /* Storing archive(s) in lk_data; see mdc_ioc_hsm_ct_start */
128         ct->kuc.lk_data = ct->archives;
129         rc = root_ioctl(ct->fsname, LL_IOC_HSM_CT_START, &(ct->kuc), NULL,
130                         WANT_ERROR);
131         /* Only the kernel reference keeps the write side open */
132         close(ct->kuc.lk_wfd);
133         ct->kuc.lk_wfd = 0;
134         if (rc < 0)
135                 goto out_kuc;
136
137         *priv = ct;
138         return 0;
139
140 out_kuc:
141         /* cleanup the kuc channel */
142         libcfs_ukuc_stop(&ct->kuc);
143 out_err:
144         if (ct->fsname)
145                 free(ct->fsname);
146         free(ct);
147         return rc;
148 }
149
150 /** Deregister a copytool
151  * Note: under Linux, until llapi_hsm_copytool_fini is called (or the program is
152  * killed), the libcfs module will be referenced and unremovable,
153  * even after Lustre services stop.
154  */
155 int llapi_hsm_copytool_fini(struct hsm_copytool_private **priv)
156 {
157         struct hsm_copytool_private *ct;
158
159         ct = *priv;
160         if (!ct || (ct->magic != CT_PRIV_MAGIC))
161                 return -EINVAL;
162
163         /* Tell the kernel to stop sending us messages */
164         ct->kuc.lk_flags = LK_FLG_STOP;
165         root_ioctl(ct->fsname, LL_IOC_HSM_CT_START, &(ct->kuc), NULL, 0);
166
167         /* Shut down the kernelcomms */
168         libcfs_ukuc_stop(&ct->kuc);
169
170         free(ct->fsname);
171         free(ct);
172         *priv = NULL;
173         return 0;
174 }
175
176 /** Wait for the next hsm_action_list
177  * \param ct Opaque private control structure
178  * \param halh Action list handle, will be allocated here
179  * \param msgsize Number of bytes in the message, will be set here
180  * \return 0 valid message received; halh and msgsize are set
181  *         <0 error code
182  */
183 int llapi_hsm_copytool_recv(struct hsm_copytool_private *ct,
184                             struct hsm_action_list **halh, int *msgsize)
185 {
186         struct kuc_hdr                  *kuch;
187         struct hsm_action_list          *hal;
188         int                              rc = 0;
189
190         if (!ct || (ct->magic != CT_PRIV_MAGIC))
191                 return -EINVAL;
192         if (halh == NULL || msgsize == NULL)
193                 return -EINVAL;
194
195         kuch = malloc(HAL_MAXSIZE + sizeof(*kuch));
196         if (kuch == NULL)
197                 return -ENOMEM;
198
199         rc = libcfs_ukuc_msg_get(&ct->kuc, (char *)kuch,
200                                  HAL_MAXSIZE + sizeof(*kuch),
201                                  KUC_TRANSPORT_HSM);
202         if (rc < 0)
203                 goto out_free;
204
205         /* Handle generic messages */
206         if (kuch->kuc_transport == KUC_TRANSPORT_GENERIC &&
207             kuch->kuc_msgtype == KUC_MSG_SHUTDOWN) {
208                 rc = -ESHUTDOWN;
209                 goto out_free;
210         }
211
212         if (kuch->kuc_transport != KUC_TRANSPORT_HSM ||
213             kuch->kuc_msgtype != HMT_ACTION_LIST) {
214                 llapi_err_noerrno(LLAPI_MSG_ERROR,
215                                   "Unknown HSM message type %d:%d\n",
216                                   kuch->kuc_transport, kuch->kuc_msgtype);
217                 rc = -EPROTO;
218                 goto out_free;
219         }
220
221         if (kuch->kuc_msglen < sizeof(*kuch) + sizeof(*hal)) {
222                 llapi_err_noerrno(LLAPI_MSG_ERROR, "Short HSM message %d",
223                                   kuch->kuc_msglen);
224                 rc = -EPROTO;
225                 goto out_free;
226         }
227
228         /* Our message is a hsm_action_list. Use pointer math to skip
229         * kuch_hdr and point directly to the message payload.
230         */
231         hal = (struct hsm_action_list *)(kuch + 1);
232
233         /* Check that we have registered for this archive #
234          * if 0 registered, we serve any archive */
235         if (ct->archives &&
236             ((1 << (hal->hal_archive_id - 1)) & ct->archives) == 0) {
237                 llapi_err_noerrno(LLAPI_MSG_INFO,
238                                   "This copytool does not service archive #%d,"
239                                   " ignoring this request."
240                                   " Mask of served archive is 0x%.8X",
241                                   hal->hal_archive_id, ct->archives);
242                 rc = -EAGAIN;
243
244                 goto out_free;
245         }
246
247         *halh = hal;
248         *msgsize = kuch->kuc_msglen - sizeof(*kuch);
249         return 0;
250
251 out_free:
252         *halh = NULL;
253         *msgsize = 0;
254         free(kuch);
255         return rc;
256 }
257
258 /** Release the action list when done with it. */
259 int llapi_hsm_copytool_free(struct hsm_action_list **hal)
260 {
261         /* Reuse the llapi_changelog_free function */
262         return llapi_changelog_free((struct changelog_ext_rec **)hal);
263 }
264
265
266 /**
267  * Should be called by copytools just before starting handling a request.
268  * It could be skipped if copytool only want to directly report an error,
269  * \see llapi_hsm_copy_end().
270  *
271  * \param mnt   Mount point of the corresponding Lustre filesystem.
272  * \param hai   The hsm_action_item describing the request they will handle.
273  * \param copy  Updated by this call. Caller will passed it to
274  *              llapi_hsm_copy_end()
275  *
276  * \return 0 on success.
277  */
278 int llapi_hsm_copy_start(char *mnt, struct hsm_copy *copy,
279                          const struct hsm_action_item *hai)
280 {
281         int     fd;
282         int     rc;
283
284         if (memcpy(&copy->hc_hai, hai, sizeof(*hai)) == NULL)
285                 RETURN(-EFAULT);
286
287         rc = get_root_path(WANT_FD, NULL, &fd, mnt, -1);
288         if (rc)
289                 return rc;
290
291         rc = ioctl(fd, LL_IOC_HSM_COPY_START, copy);
292         close(fd);
293
294         return rc;
295 }
296
297 /**
298  * Should be called by copytools just having finished handling the request.
299  *
300  * \param mnt   Mount point of the corresponding Lustre filesystem.
301  * \param copy  The element used when calling llapi_hsm_copy_start()
302  * \param hp    A hsm_progress structure describing the final state of the
303  *              request.
304  *
305  * There is a special case which can be used only when the copytool cannot
306  * start the copy at all and want to directly return an error. In this case,
307  * simply fill \a hp structure and set \a copy to NULL. It is useless to call
308  * llapi_hsm_copy_start() in this case.
309  *
310  * \return 0 on success.
311  */
312 int llapi_hsm_copy_end(char *mnt, struct hsm_copy *copy,
313                        const struct hsm_progress *hp)
314 {
315         int     end_only = 0;
316         int     fd;
317         int     rc;
318
319         /* llapi_hsm_copy_start() was skipped, so alloc copy. It will
320          * only be used to give the needed progress information. */
321         if (copy == NULL) {
322                 /* This is only ok if there is an error. */
323                 if (hp->hp_errval == 0)
324                         return -EINVAL;
325
326                 copy = (struct hsm_copy *)malloc(sizeof(*copy));
327                 if (copy == NULL)
328                         return -ENOMEM;
329                 end_only = 1;
330                 copy->hc_hai.hai_cookie = hp->hp_cookie;
331                 copy->hc_hai.hai_fid = hp->hp_fid;
332                 copy->hc_hai.hai_action = HSMA_NONE;
333         }
334
335         /* Fill the last missing data that will be needed by kernel
336          * to send a hsm_progress. */
337         copy->hc_flags = hp->hp_flags;
338         copy->hc_errval = hp->hp_errval;
339         /* Update hai if it has changed since start */
340         copy->hc_hai.hai_extent = hp->hp_extent;
341
342         rc = get_root_path(WANT_FD, NULL, &fd, mnt, -1);
343         if (rc)
344                 goto out_free;
345
346         rc = ioctl(fd, LL_IOC_HSM_COPY_END, copy);
347         close(fd);
348
349 out_free:
350         if (end_only)
351                 free(copy);
352
353         return rc;
354 }
355
356 /**
357  * Copytool progress reporting.
358  *
359  * \a hp->hp_errval should be EAGAIN until action is completely finished.
360  *
361  * \return 0 on success, an error code otherwise.
362  */
363 int llapi_hsm_progress(char *mnt, struct hsm_progress *hp)
364 {
365         int     fd;
366         int     rc;
367
368         rc = get_root_path(WANT_FD, NULL, &fd, mnt, -1);
369         if (rc)
370                 return rc;
371
372         rc = ioctl(fd, LL_IOC_HSM_PROGRESS, hp);
373         /* If error, save errno value */
374         rc = rc ? -errno : 0;
375
376         close(fd);
377         return rc;
378 }
379
380 /**
381  * Import an existing hsm-archived file into Lustre.
382  *
383  * Caller must access file by (returned) newfid value from now on.
384  *
385  * \param dst      path to Lustre destination (e.g. /mnt/lustre/my/file).
386  * \param archive  archive number.
387  * \param st       struct stat buffer containing file ownership, perm, etc.
388  * \param stripe_* Striping options.  Currently ignored, since the restore
389  *                 operation will set the striping.  In V2, this striping might
390  *                 be used.
391  * \param newfid[out] Filled with new Lustre fid.
392  */
393 int llapi_hsm_import(const char *dst, int archive, struct stat *st,
394                      unsigned long long stripe_size, int stripe_offset,
395                      int stripe_count, int stripe_pattern, char *pool_name,
396                      lustre_fid *newfid)
397 {
398         struct utimbuf  time;
399         int             fd;
400         int             rc = 0;
401
402         /* Create a non-striped file */
403         fd = open(dst, O_CREAT | O_EXCL | O_LOV_DELAY_CREATE | O_NONBLOCK,
404                   st->st_mode);
405
406         if (fd < 0)
407                 return -errno;
408         close(fd);
409
410         /* set size on MDT */
411         if (truncate(dst, st->st_size) != 0) {
412                 rc = -errno;
413                 goto out_unlink;
414         }
415         /* Mark archived */
416         rc = llapi_hsm_state_set(dst, HS_EXISTS | HS_RELEASED | HS_ARCHIVED, 0,
417                                  archive);
418         if (rc)
419                 goto out_unlink;
420
421         /* Get the new fid in the archive. Caller needs to use this fid
422            from now on. */
423         rc = llapi_path2fid(dst, newfid);
424         if (rc)
425                 goto out_unlink;
426
427         /* Copy the file attributes */
428         time.actime = st->st_atime;
429         time.modtime = st->st_mtime;
430         if (utime(dst, &time) == -1 ||
431                 chmod(dst, st->st_mode) == -1 ||
432                 chown(dst, st->st_uid, st->st_gid) == -1) {
433                 /* we might fail here because we change perms/owner */
434                 rc = -errno;
435                 goto out_unlink;
436         }
437
438 out_unlink:
439         if (rc)
440                 unlink(dst);
441         return rc;
442 }
443
444 /**
445  * Return the current HSM states and HSM requests related to file pointed by \a
446  * path.
447  *
448  * \param hus  Should be allocated by caller. Will be filled with current file
449  *             states.
450  *
451  * \retval 0 on success.
452  * \retval -errno on error.
453  */
454 int llapi_hsm_state_get(const char *path, struct hsm_user_state *hus)
455 {
456         int fd;
457         int rc;
458
459         fd = open(path, O_RDONLY | O_NONBLOCK);
460         if (fd < 0)
461                 return -errno;
462
463         rc = ioctl(fd, LL_IOC_HSM_STATE_GET, hus);
464         /* If error, save errno value */
465         rc = rc ? -errno : 0;
466
467         close(fd);
468         return rc;
469 }
470
471 /**
472  * Set HSM states of file pointed by \a path.
473  *
474  * Using the provided bitmasks, the current HSM states for this file will be
475  * changed. \a archive_id could be used to change the archive number also. Set
476  * it to 0 if you do not want to change it.
477  *
478  * \param setmask      Bitmask for flag to be set.
479  * \param clearmask    Bitmask for flag to be cleared.
480  * \param archive_id  Archive number identifier to use. 0 means no change.
481  *
482  * \retval 0 on success.
483  * \retval -errno on error.
484  */
485 int llapi_hsm_state_set(const char *path, __u64 setmask, __u64 clearmask,
486                         __u32 archive_id)
487 {
488         struct hsm_state_set hss;
489         int fd;
490         int rc;
491
492         fd = open(path, O_WRONLY | O_LOV_DELAY_CREATE | O_NONBLOCK);
493         if (fd < 0)
494                 return -errno;
495
496         hss.hss_valid = HSS_SETMASK|HSS_CLEARMASK;
497         hss.hss_setmask = setmask;
498         hss.hss_clearmask = clearmask;
499         /* Change archive_id if provided. We can only change
500          * to set something different than 0. */
501         if (archive_id > 0) {
502                 hss.hss_valid |= HSS_ARCHIVE_ID;
503                 hss.hss_archive_id = archive_id;
504         }
505         rc = ioctl(fd, LL_IOC_HSM_STATE_SET, &hss);
506         /* If error, save errno value */
507         rc = rc ? -errno : 0;
508
509         close(fd);
510         return rc;
511 }
512
513
514 /**
515  * Return the current HSM request related to file pointed by \a path.
516  *
517  * \param hca  Should be allocated by caller. Will be filled with current file
518  *             actions.
519  *
520  * \retval 0 on success.
521  * \retval -errno on error.
522  */
523 int llapi_hsm_current_action(const char *path, struct hsm_current_action *hca)
524 {
525         int fd;
526         int rc;
527
528         fd = open(path, O_RDONLY | O_NONBLOCK);
529         if (fd < 0)
530                 return -errno;
531
532         rc = ioctl(fd, LL_IOC_HSM_ACTION, hca);
533         /* If error, save errno value */
534         rc = rc ? -errno : 0;
535
536         close(fd);
537         return rc;
538 }
539
540 /**
541  * Allocate a hsm_user_request with the specified carateristics.
542  * This structure should be freed with free().
543  *
544  * \return an allocated structure on success, NULL otherwise.
545  */
546 struct hsm_user_request *llapi_hsm_user_request_alloc(int itemcount,
547                                                       int data_len)
548 {
549         int len = 0;
550
551         len += sizeof(struct hsm_user_request);
552         len += sizeof(struct hsm_user_item) * itemcount;
553         len += data_len;
554
555         return (struct hsm_user_request *)malloc(len);
556 }
557
558 /**
559  * Send a HSM request to Lustre, described in \param request.
560  *
561  * This request should be allocated with llapi_hsm_user_request_alloc().
562  *
563  * \param mnt Should be the Lustre moint point.
564  * \return 0 on success, an error code otherwise.
565  */
566 int llapi_hsm_request(char *mnt, struct hsm_user_request *request)
567 {
568         int rc;
569         int fd;
570
571         rc = get_root_path(WANT_FD, NULL, &fd, mnt, -1);
572         if (rc)
573                 return rc;
574
575         rc = ioctl(fd, LL_IOC_HSM_REQUEST, request);
576         /* If error, save errno value */
577         rc = rc ? -errno : 0;
578
579         close(fd);
580         return rc;
581 }
582