Whamcloud - gitweb
LU-10114 hsm: increase upper limit of maximum HSM backends registered with MDT
[fs/lustre-release.git] / lustre / mdt / mdt_hsm.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License version 2 for more details.  A copy is
14  * included in the COPYING file that accompanied this code.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2011, 2012 Commissariat a l'energie atomique et aux energies
24  *                          alternatives
25  * Use is subject to license terms.
26  *
27  * Copyright (c) 2012, 2015, Intel Corporation.
28  */
29 /*
30  * lustre/mdt/mdt_hsm.c
31  *
32  * Lustre Metadata Target (mdt) request handler
33  *
34  * Author: Aurelien Degremont <aurelien.degremont@cea.fr>
35  * Author: JC Lafoucriere <jacques-charles.lafoucriere@cea.fr>
36  */
37
38 #define DEBUG_SUBSYSTEM S_MDS
39
40 #include <lustre_errno.h>
41 #include "mdt_internal.h"
42
43 /* Max allocation to satisfy single HSM RPC. */
44 #define MDT_HSM_ALLOC_MAX (1 << 20)
45
46 #define MDT_HSM_ALLOC(ptr, size)                        \
47         do {                                            \
48                 if ((size) <= MDT_HSM_ALLOC_MAX)        \
49                         OBD_ALLOC_LARGE((ptr), (size)); \
50                 else                                    \
51                         (ptr) = NULL;                   \
52         } while (0)
53
54 #define MDT_HSM_FREE(ptr, size) OBD_FREE_LARGE((ptr), (size))
55
56 /**
57  * Update on-disk HSM attributes.
58  */
59 int mdt_hsm_attr_set(struct mdt_thread_info *info, struct mdt_object *obj,
60                      const struct md_hsm *mh)
61 {
62         struct md_object *next = mdt_object_child(obj);
63         struct lu_buf *buf = &info->mti_buf;
64         struct hsm_attrs *attrs;
65         int rc;
66         ENTRY;
67
68         attrs = (struct hsm_attrs *)info->mti_xattr_buf;
69         CLASSERT(sizeof(info->mti_xattr_buf) >= sizeof(*attrs));
70
71         /* pack HSM attributes */
72         lustre_hsm2buf(info->mti_xattr_buf, mh);
73
74         /* update HSM attributes */
75         buf->lb_buf = attrs;
76         buf->lb_len = sizeof(*attrs);
77         rc = mo_xattr_set(info->mti_env, next, buf, XATTR_NAME_HSM, 0);
78
79         RETURN(rc);
80 }
81
82 static inline bool mdt_hsm_is_admin(struct mdt_thread_info *info)
83 {
84         bool is_admin;
85         int rc;
86
87         if (info->mti_body == NULL)
88                 return false;
89
90         rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
91         if (rc < 0)
92                 return false;
93
94         is_admin = md_capable(mdt_ucred(info), CFS_CAP_SYS_ADMIN);
95
96         mdt_exit_ucred(info);
97
98         return is_admin;
99 }
100
101 /**
102  * Extract information coming from a copytool and asks coordinator to update
103  * a request status depending on the update content.
104  *
105  * Copytools could use this to report failure in their process.
106  *
107  * This is HSM_PROGRESS RPC handler.
108  */
109 int mdt_hsm_progress(struct tgt_session_info *tsi)
110 {
111         struct mdt_thread_info          *info;
112         struct hsm_progress_kernel      *hpk;
113         int                              rc;
114         ENTRY;
115
116         if (tsi->tsi_mdt_body == NULL)
117                 RETURN(-EPROTO);
118
119         hpk = req_capsule_client_get(tsi->tsi_pill, &RMF_MDS_HSM_PROGRESS);
120         if (hpk == NULL)
121                 RETURN(err_serious(-EPROTO));
122
123         hpk->hpk_errval = lustre_errno_ntoh(hpk->hpk_errval);
124
125         CDEBUG(D_HSM, "Progress on "DFID": len=%llu : rc = %d\n",
126                PFID(&hpk->hpk_fid), hpk->hpk_extent.length, hpk->hpk_errval);
127
128         if (hpk->hpk_errval)
129                 CDEBUG(D_HSM, "Copytool progress on "DFID" failed : rc = %d; %s.\n",
130                        PFID(&hpk->hpk_fid), hpk->hpk_errval,
131                        hpk->hpk_flags & HP_FLAG_RETRY ? "will retry" : "fatal");
132
133         if (hpk->hpk_flags & HP_FLAG_COMPLETED)
134                 CDEBUG(D_HSM, "Finished "DFID" : rc = %d; cancel cookie=%#llx\n",
135                        PFID(&hpk->hpk_fid), hpk->hpk_errval, hpk->hpk_cookie);
136
137         info = tsi2mdt_info(tsi);
138         if (!mdt_hsm_is_admin(info))
139                 GOTO(out, rc = -EPERM);
140
141         rc = mdt_hsm_update_request_state(info, hpk);
142 out:
143         mdt_thread_info_fini(info);
144         RETURN(rc);
145 }
146
147 int mdt_hsm_ct_register(struct tgt_session_info *tsi)
148 {
149         struct mdt_thread_info *info = tsi2mdt_info(tsi);
150         struct ptlrpc_request *req = mdt_info_req(info);
151         struct obd_export *exp = req->rq_export;
152         size_t archives_size;
153         __u32 *archives;
154         int archive_count;
155         int rc;
156         ENTRY;
157
158         if (!mdt_hsm_is_admin(info))
159                 GOTO(out, rc = -EPERM);
160
161         archives = req_capsule_client_get(tsi->tsi_pill, &RMF_MDS_HSM_ARCHIVE);
162         if (archives == NULL)
163                 GOTO(out, rc = err_serious(-EPROTO));
164
165         archives_size = req_capsule_get_size(tsi->tsi_pill,
166                                              &RMF_MDS_HSM_ARCHIVE, RCL_CLIENT);
167
168         /* compatibility check for the old clients */
169         if (!exp_connect_archive_id_array(exp)) {
170                 if (archives_size != sizeof(*archives))
171                         GOTO(out, rc = err_serious(-EPROTO));
172
173                 /* XXX: directly include this function here? */
174                 rc = mdt_hsm_agent_register_mask(info,
175                                                  &tsi->tsi_exp->exp_client_uuid,
176                                                  *archives);
177                 GOTO(out, rc);
178         }
179
180         if (archives_size % sizeof(*archives) != 0)
181                 GOTO(out, rc = err_serious(-EPROTO));
182
183         archive_count = archives_size / sizeof(*archives);
184         if (archive_count == 1 && *archives == 0) {
185                 archive_count = 0;
186                 archives = NULL;
187         }
188
189         rc = mdt_hsm_agent_register(info, &tsi->tsi_exp->exp_client_uuid,
190                                     archive_count, archives);
191
192 out:
193         mdt_thread_info_fini(info);
194         RETURN(rc);
195 }
196
197 int mdt_hsm_ct_unregister(struct tgt_session_info *tsi)
198 {
199         struct mdt_thread_info  *info;
200         int                      rc;
201         ENTRY;
202
203         if (tsi->tsi_mdt_body == NULL)
204                 RETURN(-EPROTO);
205
206         info = tsi2mdt_info(tsi);
207         if (!mdt_hsm_is_admin(info))
208                 GOTO(out, rc = -EPERM);
209
210         /* XXX: directly include this function here? */
211         rc = mdt_hsm_agent_unregister(info, &tsi->tsi_exp->exp_client_uuid);
212 out:
213         mdt_thread_info_fini(info);
214         RETURN(rc);
215 }
216
217 /**
218  * Retrieve the current HSM flags, archive id and undergoing HSM requests for
219  * the fid provided in RPC body.
220  *
221  * Current requests are read from coordinator states.
222  *
223  * This is MDS_HSM_STATE_GET RPC handler.
224  */
225 int mdt_hsm_state_get(struct tgt_session_info *tsi)
226 {
227         struct mdt_thread_info  *info = tsi2mdt_info(tsi);
228         struct mdt_object       *obj = info->mti_object;
229         struct md_attr          *ma  = &info->mti_attr;
230         struct hsm_user_state   *hus;
231         struct mdt_lock_handle  *lh;
232         int                      rc;
233         ENTRY;
234
235         if (info->mti_body == NULL || obj == NULL)
236                 GOTO(out, rc = -EPROTO);
237
238         /* Only valid if client is remote */
239         rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
240         if (rc < 0)
241                 GOTO(out, rc = err_serious(rc));
242
243         lh = &info->mti_lh[MDT_LH_CHILD];
244         mdt_lock_reg_init(lh, LCK_PR);
245         rc = mdt_object_lock(info, obj, lh, MDS_INODELOCK_LOOKUP);
246         if (rc < 0)
247                 GOTO(out_ucred, rc);
248
249         ma->ma_valid = 0;
250         ma->ma_need = MA_HSM;
251         rc = mdt_attr_get_complex(info, obj, ma);
252         if (rc)
253                 GOTO(out_unlock, rc);
254
255         hus = req_capsule_server_get(tsi->tsi_pill, &RMF_HSM_USER_STATE);
256         if (hus == NULL)
257                 GOTO(out_unlock, rc = -EPROTO);
258
259         /* Current HSM flags */
260         hus->hus_states = ma->ma_hsm.mh_flags;
261         hus->hus_archive_id = ma->ma_hsm.mh_arch_id;
262
263         EXIT;
264 out_unlock:
265         mdt_object_unlock(info, obj, lh, 1);
266 out_ucred:
267         mdt_exit_ucred(info);
268 out:
269         mdt_thread_info_fini(info);
270         return rc;
271 }
272
273 /**
274  * Change HSM state and archive number of a file.
275  *
276  * Archive number is changed iif the value is not 0.
277  * The new flagset that will be computed should result in a coherent state.
278  * This function checks that flags are compatible.
279  *
280  * This is MDS_HSM_STATE_SET RPC handler.
281  */
282 int mdt_hsm_state_set(struct tgt_session_info *tsi)
283 {
284         struct mdt_thread_info  *info = tsi2mdt_info(tsi);
285         struct mdt_object       *obj = info->mti_object;
286         struct md_attr          *ma = &info->mti_attr;
287         struct hsm_state_set    *hss;
288         struct mdt_lock_handle  *lh;
289         int                      rc;
290         __u64                    flags;
291         ENTRY;
292
293         hss = req_capsule_client_get(info->mti_pill, &RMF_HSM_STATE_SET);
294
295         if (info->mti_body == NULL || obj == NULL || hss == NULL)
296                 GOTO(out, rc = -EPROTO);
297
298         /* Only valid if client is remote */
299         rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
300         if (rc < 0)
301                 GOTO(out, rc = err_serious(rc));
302
303         lh = &info->mti_lh[MDT_LH_CHILD];
304         mdt_lock_reg_init(lh, LCK_PW);
305         rc = mdt_object_lock(info, obj, lh, MDS_INODELOCK_LOOKUP |
306                              MDS_INODELOCK_XATTR);
307         if (rc < 0)
308                 GOTO(out_ucred, rc);
309
310         /* Detect out-of range masks */
311         if ((hss->hss_setmask | hss->hss_clearmask) & ~HSM_FLAGS_MASK) {
312                 CDEBUG(D_HSM, "Incompatible masks provided (set %#llx"
313                        ", clear %#llx) vs supported set (%#x).\n",
314                        hss->hss_setmask, hss->hss_clearmask, HSM_FLAGS_MASK);
315                 GOTO(out_unlock, rc = -EINVAL);
316         }
317
318         /* Non-root users are forbidden to set or clear flags which are
319          * NOT defined in HSM_USER_MASK. */
320         if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
321             !md_capable(mdt_ucred(info), CFS_CAP_SYS_ADMIN)) {
322                 CDEBUG(D_HSM, "Incompatible masks provided (set %#llx"
323                        ", clear %#llx) vs unprivileged set (%#x).\n",
324                        hss->hss_setmask, hss->hss_clearmask, HSM_USER_MASK);
325                 GOTO(out_unlock, rc = -EPERM);
326         }
327
328         /* Read current HSM info */
329         ma->ma_valid = 0;
330         ma->ma_need = MA_HSM;
331         rc = mdt_attr_get_complex(info, obj, ma);
332         if (rc)
333                 GOTO(out_unlock, rc);
334
335         /* Change HSM flags depending on provided masks */
336         if (hss->hss_valid & HSS_SETMASK)
337                 ma->ma_hsm.mh_flags |= hss->hss_setmask;
338         if (hss->hss_valid & HSS_CLEARMASK)
339                 ma->ma_hsm.mh_flags &= ~hss->hss_clearmask;
340
341         /* Change archive_id if provided. */
342         if (hss->hss_valid & HSS_ARCHIVE_ID) {
343                 struct ptlrpc_request *req = mdt_info_req(info);
344                 struct obd_export *exp = req->rq_export;
345
346                 if (!(ma->ma_hsm.mh_flags & HS_EXISTS)) {
347                         CDEBUG(D_HSM, "Could not set an archive number for "
348                                DFID "if HSM EXISTS flag is not set.\n",
349                                PFID(&info->mti_body->mbo_fid1));
350                         GOTO(out_unlock, rc);
351                 }
352
353                 if (!exp_connect_archive_id_array(exp) &&
354                     hss->hss_archive_id > LL_HSM_ORIGIN_MAX_ARCHIVE) {
355                         CDEBUG(D_HSM, "archive id %u from old clients "
356                                "exceeds maximum %zu.\n",
357                                hss->hss_archive_id, LL_HSM_ORIGIN_MAX_ARCHIVE);
358                         GOTO(out_unlock, rc = -EINVAL);
359                 }
360
361                 ma->ma_hsm.mh_arch_id = hss->hss_archive_id;
362         }
363
364         /* Check for inconsistant HSM flagset.
365          * DIRTY without EXISTS: no dirty if no archive was created.
366          * DIRTY and RELEASED: a dirty file could not be released.
367          * RELEASED without ARCHIVED: do not release a non-archived file.
368          * LOST without ARCHIVED: cannot lost a non-archived file.
369          */
370         flags = ma->ma_hsm.mh_flags;
371         if ((flags & HS_DIRTY    && !(flags & HS_EXISTS)) ||
372             (flags & HS_RELEASED && flags & HS_DIRTY) ||
373             (flags & HS_RELEASED && !(flags & HS_ARCHIVED)) ||
374             (flags & HS_LOST     && !(flags & HS_ARCHIVED))) {
375                 CDEBUG(D_HSM, "Incompatible flag change on "DFID
376                               "flags=%#llx\n",
377                        PFID(&info->mti_body->mbo_fid1), flags);
378                 GOTO(out_unlock, rc = -EINVAL);
379         }
380
381         /* Save the modified flags */
382         rc = mdt_hsm_attr_set(info, obj, &ma->ma_hsm);
383         if (rc)
384                 GOTO(out_unlock, rc);
385
386         EXIT;
387
388 out_unlock:
389         mdt_object_unlock(info, obj, lh, 1);
390 out_ucred:
391         mdt_exit_ucred(info);
392 out:
393         mdt_thread_info_fini(info);
394         return rc;
395 }
396
397 /**
398  * Retrieve undergoing HSM requests for the fid provided in RPC body.
399  * Current requests are read from coordinator states.
400  *
401  * This is MDS_HSM_ACTION RPC handler.
402  */
403 int mdt_hsm_action(struct tgt_session_info *tsi)
404 {
405         struct mdt_thread_info *info;
406         struct hsm_current_action *hca;
407         enum hsm_copytool_action action; /* HSMA_* */
408         enum agent_req_status status; /* ARS_* */
409         struct hsm_extent extent;
410         int rc;
411         ENTRY;
412
413         hca = req_capsule_server_get(tsi->tsi_pill,
414                                      &RMF_MDS_HSM_CURRENT_ACTION);
415         if (hca == NULL)
416                 RETURN(err_serious(-EPROTO));
417
418         if (tsi->tsi_mdt_body == NULL)
419                 RETURN(-EPROTO);
420
421         info = tsi2mdt_info(tsi);
422         /* Only valid if client is remote */
423         rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
424         if (rc < 0)
425                 GOTO(out, rc = err_serious(rc));
426
427         rc = mdt_hsm_get_action(info, &info->mti_body->mbo_fid1, &action,
428                                 &status, &extent);
429         if (rc < 0)
430                 GOTO(out_ucred, rc);
431
432         switch (action) {
433         case HSMA_NONE:
434                 hca->hca_action = HUA_NONE;
435                 break;
436         case HSMA_ARCHIVE:
437                 hca->hca_action = HUA_ARCHIVE;
438                 break;
439         case HSMA_RESTORE:
440                 hca->hca_action = HUA_RESTORE;
441                 break;
442         case HSMA_REMOVE:
443                 hca->hca_action = HUA_REMOVE;
444                 break;
445         case HSMA_CANCEL:
446                 hca->hca_action = HUA_CANCEL;
447                 break;
448         default:
449                 hca->hca_action = HUA_NONE;
450                 CERROR("%s: Unknown hsm action: %d on "DFID"\n",
451                        mdt_obd_name(info->mti_mdt), action,
452                        PFID(&info->mti_body->mbo_fid1));
453                 break;
454         }
455
456         switch (status) {
457         case ARS_WAITING:
458                 hca->hca_state = HPS_WAITING;
459                 break;
460         case ARS_STARTED:
461                 hca->hca_state = HPS_RUNNING;
462                 break;
463         default:
464                 hca->hca_state = HPS_NONE;
465                 break;
466         }
467
468         hca->hca_location = extent;
469
470         EXIT;
471 out_ucred:
472         mdt_exit_ucred(info);
473 out:
474         mdt_thread_info_fini(info);
475         return rc;
476 }
477
478 /* Return true if a FID is present in an action list. */
479 static bool is_fid_in_hal(struct hsm_action_list *hal, const struct lu_fid *fid)
480 {
481         struct hsm_action_item *hai;
482         int i;
483
484         for (hai = hai_first(hal), i = 0;
485              i < hal->hal_count;
486              i++, hai = hai_next(hai)) {
487                 if (lu_fid_eq(&hai->hai_fid, fid))
488                         return true;
489         }
490
491         return false;
492 }
493
494 /**
495  * Process the HSM actions described in a struct hsm_user_request.
496  *
497  * The action described in hur will be send to coordinator to be saved and
498  * processed later or either handled directly if hur.hur_action is HUA_RELEASE.
499  *
500  * This is MDS_HSM_REQUEST RPC handler.
501  */
502 int mdt_hsm_request(struct tgt_session_info *tsi)
503 {
504         struct mdt_thread_info          *info;
505         struct req_capsule              *pill = tsi->tsi_pill;
506         struct hsm_request              *hr;
507         struct hsm_user_item            *hui;
508         struct hsm_action_list          *hal;
509         struct hsm_action_item          *hai;
510         const void                      *data;
511         int                              hui_list_size;
512         int                              data_size;
513         enum hsm_copytool_action         action = HSMA_NONE;
514         int                              hal_size, i, rc;
515         ENTRY;
516
517         hr = req_capsule_client_get(pill, &RMF_MDS_HSM_REQUEST);
518         hui = req_capsule_client_get(pill, &RMF_MDS_HSM_USER_ITEM);
519         data = req_capsule_client_get(pill, &RMF_GENERIC_DATA);
520
521         if (tsi->tsi_mdt_body == NULL || hr == NULL || hui == NULL || data == NULL)
522                 RETURN(-EPROTO);
523
524         /* Sanity check. Nothing to do with an empty list */
525         if (hr->hr_itemcount == 0)
526                 RETURN(0);
527
528         hui_list_size = req_capsule_get_size(pill, &RMF_MDS_HSM_USER_ITEM,
529                                              RCL_CLIENT);
530         if (hui_list_size < hr->hr_itemcount * sizeof(*hui))
531                 RETURN(-EPROTO);
532
533         data_size = req_capsule_get_size(pill, &RMF_GENERIC_DATA, RCL_CLIENT);
534         if (data_size != hr->hr_data_len)
535                 RETURN(-EPROTO);
536
537         info = tsi2mdt_info(tsi);
538         /* Only valid if client is remote */
539         rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
540         if (rc)
541                 GOTO(out, rc);
542
543         switch (hr->hr_action) {
544         /* code to be removed in hsm1_merge and final patch */
545         case HUA_RELEASE:
546                 CERROR("Release action is not working in hsm1_coord\n");
547                 GOTO(out_ucred, rc = -EINVAL);
548                 break;
549         /* end of code to be removed */
550         case HUA_ARCHIVE:
551                 action = HSMA_ARCHIVE;
552                 break;
553         case HUA_RESTORE:
554                 action = HSMA_RESTORE;
555                 break;
556         case HUA_REMOVE:
557                 action = HSMA_REMOVE;
558                 break;
559         case HUA_CANCEL:
560                 action = HSMA_CANCEL;
561                 break;
562         default:
563                 CERROR("Unknown hsm action: %d\n", hr->hr_action);
564                 GOTO(out_ucred, rc = -EINVAL);
565         }
566
567         hal_size = sizeof(*hal) + cfs_size_round(MTI_NAME_MAXLEN) /* fsname */ +
568                    (sizeof(*hai) + cfs_size_round(hr->hr_data_len)) *
569                    hr->hr_itemcount;
570
571         MDT_HSM_ALLOC(hal, hal_size);
572         if (hal == NULL)
573                 GOTO(out_ucred, rc = -ENOMEM);
574
575         hal->hal_version = HAL_VERSION;
576         hal->hal_archive_id = hr->hr_archive_id;
577         hal->hal_flags = hr->hr_flags;
578         obd_uuid2fsname(hal->hal_fsname, mdt_obd_name(info->mti_mdt),
579                         MTI_NAME_MAXLEN);
580
581         hal->hal_count = 0;
582         hai = hai_first(hal);
583         for (i = 0; i < hr->hr_itemcount; i++, hai = hai_next(hai)) {
584                 /* Get rid of duplicate entries. Otherwise we get
585                  * duplicated work in the llog. */
586                 if (is_fid_in_hal(hal, &hui[i].hui_fid))
587                         continue;
588
589                 hai->hai_action = action;
590                 hai->hai_cookie = 0;
591                 hai->hai_gid = 0;
592                 hai->hai_fid = hui[i].hui_fid;
593                 hai->hai_extent = hui[i].hui_extent;
594                 memcpy(hai->hai_data, data, hr->hr_data_len);
595                 hai->hai_len = sizeof(*hai) + hr->hr_data_len;
596
597                 hal->hal_count++;
598         }
599
600         rc = mdt_hsm_add_actions(info, hal);
601
602         MDT_HSM_FREE(hal, hal_size);
603
604         GOTO(out_ucred, rc);
605
606 out_ucred:
607         mdt_exit_ucred(info);
608 out:
609         mdt_thread_info_fini(info);
610         return rc;
611 }