Whamcloud - gitweb
LU-2813 hsm: Add user credential information to copy tool RPC
[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) 2012, Intel Corporation.
24  * Use is subject to license terms.
25  * Copyright (c) 2011, 2012 Commissariat a l'energie atomique et aux energies
26  *                          alternatives
27  */
28 /*
29  * lustre/mdt/mdt_hsm.c
30  *
31  * Lustre Metadata Target (mdt) request handler
32  *
33  * Author: Aurelien Degremont <aurelien.degremont@cea.fr>
34  * Author: JC Lafoucriere <jacques-charles.lafoucriere@cea.fr>
35  */
36
37 #ifndef EXPORT_SYMTAB
38 # define EXPORT_SYMTAB
39 #endif
40 #define DEBUG_SUBSYSTEM S_MDS
41
42 #include "mdt_internal.h"
43
44 /* Max allocation to satisfy single HSM RPC. */
45 #define MDT_HSM_ALLOC_MAX (1 << 20)
46
47 #define MDT_HSM_ALLOC(ptr, size)                        \
48         do {                                            \
49                 if ((size) <= MDT_HSM_ALLOC_MAX)        \
50                         OBD_ALLOC_LARGE((ptr), (size)); \
51                 else                                    \
52                         (ptr) = NULL;                   \
53         } while (0)
54
55 #define MDT_HSM_FREE(ptr, size) OBD_FREE_LARGE((ptr), (size))
56
57 /*
58  * fake functions, will be replace by real one with HSM Coordinator patch
59  */
60
61 int mdt_hsm_copytool_send(struct obd_export *exp)
62 {
63         return 0;
64 }
65
66 static int mdt_hsm_coordinator_update(struct mdt_thread_info *info,
67                                       struct hsm_progress_kernel *pgs)
68 {
69         return 0;
70 }
71
72 static int mdt_hsm_agent_register_mask(struct mdt_thread_info *info,
73                                        struct obd_uuid *uuid,
74                                        __u32 archive_mask)
75 {
76         return 0;
77 }
78
79 static int mdt_hsm_agent_unregister(struct mdt_thread_info *info,
80                                     struct obd_uuid *uuid)
81 {
82         return 0;
83 }
84
85 static int mdt_hsm_coordinator_get_actions(struct mdt_thread_info *mti,
86                                            struct hsm_action_list *hal)
87 {
88         return 0;
89 }
90
91 static int mdt_hsm_coordinator_actions(struct mdt_thread_info *info,
92                                        struct hsm_action_list *hal,
93                                        __u64 *compound_id,
94                                        int mti_attr_is_valid)
95 {
96         return 0;
97 }
98
99 /**
100  * Update on-disk HSM attributes.
101  */
102 int mdt_hsm_attr_set(struct mdt_thread_info *info, struct mdt_object *obj,
103                      struct md_hsm *mh)
104 {
105         struct md_object        *next = mdt_object_child(obj);
106         struct lu_buf           *buf = &info->mti_buf;
107         struct hsm_attrs        *attrs;
108         int                      rc;
109         ENTRY;
110
111         attrs = (struct hsm_attrs *)info->mti_xattr_buf;
112         CLASSERT(sizeof(info->mti_xattr_buf) >= sizeof(*attrs));
113
114         /* pack HSM attributes */
115         lustre_hsm2buf(info->mti_xattr_buf, mh);
116
117         /* update SOM attributes */
118         buf->lb_buf = attrs;
119         buf->lb_len = sizeof(*attrs);
120         rc = mo_xattr_set(info->mti_env, next, buf, XATTR_NAME_HSM, 0);
121
122         RETURN(rc);
123 }
124
125 /**
126  * Extract information coming from a copytool and asks coordinator to update
127  * a request status depending on the update content.
128  *
129  * Copytools could use this to report failure in their process.
130  *
131  * This is HSM_PROGRESS RPC handler.
132  */
133 int mdt_hsm_progress(struct mdt_thread_info *info)
134 {
135         struct mdt_body                 *body;
136         struct hsm_progress_kernel      *hpk;
137         int                              rc;
138         ENTRY;
139
140         body = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
141         if (body == NULL)
142                 RETURN(-EPROTO);
143
144         hpk = req_capsule_client_get(info->mti_pill, &RMF_MDS_HSM_PROGRESS);
145         if (hpk == NULL)
146                 RETURN(-EPROTO);
147
148         CDEBUG(D_HSM, "Progress on "DFID": len="LPU64" err=%d\n",
149                PFID(&hpk->hpk_fid), hpk->hpk_extent.length, hpk->hpk_errval);
150
151         if (hpk->hpk_errval)
152                 CDEBUG(D_HSM, "Copytool progress on "DFID" failed (%d); %s.\n",
153                        PFID(&hpk->hpk_fid), hpk->hpk_errval,
154                        hpk->hpk_flags & HP_FLAG_RETRY ? "will retry" : "fatal");
155
156         if (hpk->hpk_flags & HP_FLAG_COMPLETED)
157                 CDEBUG(D_HSM, "Finished "DFID" (%d) cancel cookie="LPX64"\n",
158                        PFID(&hpk->hpk_fid), hpk->hpk_errval, hpk->hpk_cookie);
159
160         rc = mdt_hsm_coordinator_update(info, hpk);
161
162         RETURN(rc);
163 }
164
165 int mdt_hsm_ct_register(struct mdt_thread_info *info)
166 {
167         struct mdt_body         *body;
168         struct ptlrpc_request   *req = mdt_info_req(info);
169         __u32                   *archives;
170         int                      rc;
171         ENTRY;
172
173         body = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
174         if (body == NULL)
175                 RETURN(-EPROTO);
176
177         archives = req_capsule_client_get(info->mti_pill, &RMF_MDS_HSM_ARCHIVE);
178         if (archives == NULL)
179                 RETURN(-EPROTO);
180
181         /* XXX: directly include this function here? */
182         rc = mdt_hsm_agent_register_mask(info, &req->rq_export->exp_client_uuid,
183                                          *archives);
184
185         RETURN(rc);
186 }
187
188 int mdt_hsm_ct_unregister(struct mdt_thread_info *info)
189 {
190         struct mdt_body         *body;
191         struct ptlrpc_request   *req = mdt_info_req(info);
192         int                      rc;
193         ENTRY;
194
195         body = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
196         if (body == NULL)
197                 RETURN(-EPROTO);
198
199         /* XXX: directly include this function here? */
200         rc = mdt_hsm_agent_unregister(info, &req->rq_export->exp_client_uuid);
201
202         RETURN(rc);
203 }
204
205 /**
206  * Retrieve the current HSM flags, archive id and undergoing HSM requests for
207  * the fid provided in RPC body.
208  *
209  * Current requests are read from coordinator states.
210  *
211  * This is MDS_HSM_STATE_GET RPC handler.
212  */
213 int mdt_hsm_state_get(struct mdt_thread_info *info)
214 {
215         struct mdt_object       *obj = info->mti_object;
216         struct md_attr          *ma  = &info->mti_attr;
217         struct hsm_user_state   *hus;
218         struct mdt_lock_handle  *lh;
219         int                      rc;
220         ENTRY;
221
222         lh = &info->mti_lh[MDT_LH_CHILD];
223         mdt_lock_reg_init(lh, LCK_PR);
224         rc = mdt_object_lock(info, obj, lh, MDS_INODELOCK_LOOKUP,
225                              MDT_LOCAL_LOCK);
226         if (rc)
227                 RETURN(rc);
228
229         /* Only valid if client is remote */
230         rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
231         if (rc)
232                 GOTO(out_unlock, rc = err_serious(rc));
233
234         ma->ma_valid = 0;
235         ma->ma_need = MA_HSM;
236         rc = mdt_attr_get_complex(info, obj, ma);
237         if (rc)
238                 GOTO(out_ucred, rc);
239
240         if (req_capsule_get_size(info->mti_pill, &RMF_CAPA1, RCL_CLIENT))
241                 mdt_set_capainfo(info, 0, &info->mti_body->fid1,
242                             req_capsule_client_get(info->mti_pill, &RMF_CAPA1));
243
244         hus = req_capsule_server_get(info->mti_pill, &RMF_HSM_USER_STATE);
245         if (hus == NULL)
246                 GOTO(out_ucred, rc = -EPROTO);
247
248         /* Current HSM flags */
249         hus->hus_states = ma->ma_hsm.mh_flags;
250         hus->hus_archive_id = ma->ma_hsm.mh_arch_id;
251
252         EXIT;
253 out_ucred:
254         mdt_exit_ucred(info);
255 out_unlock:
256         mdt_object_unlock(info, obj, lh, 1);
257         return rc;
258 }
259
260 /**
261  * Change HSM state and archive number of a file.
262  *
263  * Archive number is changed iif the value is not 0.
264  * The new flagset that will be computed should result in a coherent state.
265  * This function checks that are flags are compatible.
266  *
267  * This is MDS_HSM_STATE_SET RPC handler.
268  */
269 int mdt_hsm_state_set(struct mdt_thread_info *info)
270 {
271         struct mdt_object       *obj = info->mti_object;
272         struct md_attr          *ma = &info->mti_attr;
273         struct hsm_state_set    *hss;
274         struct mdt_lock_handle  *lh;
275         int                      rc;
276         __u64                    flags;
277         ENTRY;
278
279         lh = &info->mti_lh[MDT_LH_CHILD];
280         mdt_lock_reg_init(lh, LCK_PW);
281         rc = mdt_object_lock(info, obj, lh, MDS_INODELOCK_LOOKUP,
282                              MDT_LOCAL_LOCK);
283         if (rc)
284                 RETURN(rc);
285
286         /* Only valid if client is remote */
287         rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
288         if (rc)
289                 GOTO(out_obj, rc = err_serious(rc));
290
291         /* Read current HSM info */
292         ma->ma_valid = 0;
293         ma->ma_need = MA_HSM;
294         rc = mdt_attr_get_complex(info, obj, ma);
295         if (rc)
296                 GOTO(out_ucred, rc);
297
298         hss = req_capsule_client_get(info->mti_pill, &RMF_HSM_STATE_SET);
299         if (hss == NULL)
300                 GOTO(out_ucred, rc = -EPROTO);
301
302         if (req_capsule_get_size(info->mti_pill, &RMF_CAPA1, RCL_CLIENT))
303                 mdt_set_capainfo(info, 0, &info->mti_body->fid1,
304                             req_capsule_client_get(info->mti_pill, &RMF_CAPA1));
305
306         /* Change HSM flags depending on provided masks */
307         if (hss->hss_valid & HSS_SETMASK)
308                 ma->ma_hsm.mh_flags |= hss->hss_setmask;
309         if (hss->hss_valid & HSS_CLEARMASK)
310                 ma->ma_hsm.mh_flags &= ~hss->hss_clearmask;
311
312         /* Change archive_id if provided. */
313         if (hss->hss_valid & HSS_ARCHIVE_ID) {
314                 if (!(ma->ma_hsm.mh_flags & HS_EXISTS)) {
315                         CDEBUG(D_HSM, "Could not set an archive number for "
316                                DFID "if HSM EXISTS flag is not set.\n",
317                                PFID(&info->mti_body->fid1));
318                         GOTO(out_ucred, rc);
319                 }
320                 ma->ma_hsm.mh_arch_id = hss->hss_archive_id;
321         }
322
323         /* Check for inconsistant HSM flagset.
324          * DIRTY without EXISTS: no dirty if no archive was created.
325          * DIRTY and RELEASED: a dirty file could not be released.
326          * RELEASED without ARCHIVED: do not release a non-archived file.
327          * LOST without ARCHIVED: cannot lost a non-archived file.
328          */
329         flags = ma->ma_hsm.mh_flags;
330         if (((flags & HS_DIRTY) && !(flags & HS_EXISTS)) ||
331             ((flags & HS_RELEASED) && (flags & HS_DIRTY)) ||
332             ((flags & HS_RELEASED) && !(flags & HS_ARCHIVED)) ||
333             ((flags & HS_LOST)     && !(flags & HS_ARCHIVED))) {
334                 CDEBUG(D_HSM, "Incompatible flag change on "DFID
335                               "flags="LPX64"\n",
336                        PFID(&info->mti_body->fid1), flags);
337                 GOTO(out_ucred, rc = -EINVAL);
338         }
339
340         /* Save the modified flags */
341         rc = mdt_hsm_attr_set(info, obj, &ma->ma_hsm);
342         if (rc)
343                 GOTO(out_ucred, rc);
344
345         EXIT;
346
347 out_ucred:
348         mdt_exit_ucred(info);
349 out_obj:
350         mdt_object_unlock(info, obj, lh, 1);
351         return rc;
352 }
353
354 /**
355  * Retrieve undergoing HSM requests for the fid provided in RPC body.
356  * Current requests are read from coordinator states.
357  *
358  * This is MDS_HSM_ACTION RPC handler.
359  */
360 int mdt_hsm_action(struct mdt_thread_info *info)
361 {
362         struct hsm_current_action       *hca;
363         struct hsm_action_list          *hal = NULL;
364         struct hsm_action_item          *hai;
365         int                              hal_size;
366         int                              rc;
367         ENTRY;
368
369         /* Only valid if client is remote */
370         rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
371         if (rc)
372                 RETURN(rc = err_serious(rc));
373
374         if (req_capsule_get_size(info->mti_pill, &RMF_CAPA1, RCL_CLIENT))
375                 mdt_set_capainfo(info, 0, &info->mti_body->fid1,
376                                  req_capsule_client_get(info->mti_pill,
377                                                         &RMF_CAPA1));
378
379         hca = req_capsule_server_get(info->mti_pill,
380                                      &RMF_MDS_HSM_CURRENT_ACTION);
381         if (hca == NULL)
382                 GOTO(out_ucred, rc = -EPROTO);
383
384         /* Coordinator information */
385         hal_size = sizeof(*hal) +
386                    cfs_size_round(MTI_NAME_MAXLEN) /* fsname */ +
387                    cfs_size_round(sizeof(*hai));
388
389         MDT_HSM_ALLOC(hal, hal_size);
390         if (hal == NULL)
391                 GOTO(out_ucred, rc = -ENOMEM);
392
393         hal->hal_version = HAL_VERSION;
394         hal->hal_archive_id = 0;
395         hal->hal_flags = 0;
396         obd_uuid2fsname(hal->hal_fsname, mdt2obd_dev(info->mti_mdt)->obd_name,
397                         MTI_NAME_MAXLEN);
398         hal->hal_count = 1;
399         hai = hai_zero(hal);
400         hai->hai_action = HSMA_NONE;
401         hai->hai_cookie = 0;
402         hai->hai_gid = 0;
403         hai->hai_fid = info->mti_body->fid1;
404         hai->hai_len = sizeof(*hai);
405
406         rc = mdt_hsm_coordinator_get_actions(info, hal);
407         if (rc)
408                 GOTO(out_free, rc);
409
410         /* cookie is used to give back request status */
411         if (hai->hai_cookie == 0)
412                 hca->hca_state = HPS_WAITING;
413         else
414                 hca->hca_state = HPS_RUNNING;
415
416         switch (hai->hai_action) {
417         case HSMA_NONE:
418                 hca->hca_action = HUA_NONE;
419                 break;
420         case HSMA_ARCHIVE:
421                 hca->hca_action = HUA_ARCHIVE;
422                 break;
423         case HSMA_RESTORE:
424                 hca->hca_action = HUA_RESTORE;
425                 break;
426         case HSMA_REMOVE:
427                 hca->hca_action = HUA_REMOVE;
428                 break;
429         case HSMA_CANCEL:
430                 hca->hca_action = HUA_CANCEL;
431                 break;
432         default:
433                 hca->hca_action = HUA_NONE;
434                 CERROR("%s: Unknown hsm action: %d on "DFID"\n",
435                        mdt2obd_dev(info->mti_mdt)->obd_name,
436                        hai->hai_action, PFID(&hai->hai_fid));
437                 break;
438         }
439
440         hca->hca_location = hai->hai_extent;
441
442         EXIT;
443 out_free:
444         MDT_HSM_FREE(hal, hal_size);
445 out_ucred:
446         mdt_exit_ucred(info);
447         return rc;
448 }
449
450 /**
451  * Process the HSM actions described in a struct hsm_user_request.
452  *
453  * The action described in hur will be send to coordinator to be saved and
454  * processed later or either handled directly if hur.hur_action is HUA_RELEASE.
455  *
456  * This is MDS_HSM_REQUEST RPC handler.
457  */
458 int mdt_hsm_request(struct mdt_thread_info *info)
459 {
460         struct req_capsule              *pill = info->mti_pill;
461         struct mdt_body                 *body;
462         struct hsm_request              *hr;
463         struct hsm_user_item            *hui;
464         struct hsm_action_list          *hal;
465         struct hsm_action_item          *hai;
466         const void                      *data;
467         int                              hui_list_size;
468         int                              data_size;
469         enum hsm_copytool_action         action = HSMA_NONE;
470         __u64                            compound_id;
471         int                              hal_size, i, rc;
472         ENTRY;
473
474         body = req_capsule_client_get(pill, &RMF_MDT_BODY);
475         hr = req_capsule_client_get(pill, &RMF_MDS_HSM_REQUEST);
476         hui = req_capsule_client_get(pill, &RMF_MDS_HSM_USER_ITEM);
477         data = req_capsule_client_get(pill, &RMF_GENERIC_DATA);
478
479         if (body == NULL || hr == NULL || hui == NULL || data == NULL)
480                 RETURN(-EPROTO);
481
482         /* Sanity check. Nothing to do with an empty list */
483         if (hr->hr_itemcount == 0)
484                 RETURN(0);
485
486         hui_list_size = req_capsule_get_size(pill, &RMF_MDS_HSM_USER_ITEM,
487                                              RCL_CLIENT);
488         if (hui_list_size < hr->hr_itemcount * sizeof(*hui))
489                 RETURN(-EPROTO);
490
491         data_size = req_capsule_get_size(pill, &RMF_GENERIC_DATA, RCL_CLIENT);
492         if (data_size != hr->hr_data_len)
493                 RETURN(-EPROTO);
494
495         /* Only valid if client is remote */
496         rc = mdt_init_ucred(info, body);
497         if (rc)
498                 RETURN(err_serious(rc));
499
500         switch (hr->hr_action) {
501         /* code to be removed in hsm1_merge and final patch */
502         case HUA_RELEASE:
503                 CERROR("Release action is not working in hsm1_coord\n");
504                 GOTO(out_ucred, rc = -EINVAL);
505                 break;
506         /* end of code to be removed */
507         case HUA_ARCHIVE:
508                 action = HSMA_ARCHIVE;
509                 break;
510         case HUA_RESTORE:
511                 action = HSMA_RESTORE;
512                 break;
513         case HUA_REMOVE:
514                 action = HSMA_REMOVE;
515                 break;
516         case HUA_CANCEL:
517                 action = HSMA_CANCEL;
518                 break;
519         default:
520                 CERROR("Unknown hsm action: %d\n", hr->hr_action);
521                 GOTO(out_ucred, rc = -EINVAL);
522         }
523
524         hal_size = sizeof(*hal) + cfs_size_round(MTI_NAME_MAXLEN) /* fsname */ +
525                    (sizeof(*hai) + cfs_size_round(hr->hr_data_len)) *
526                    hr->hr_itemcount;
527
528         MDT_HSM_ALLOC(hal, hal_size);
529         if (hal == NULL)
530                 GOTO(out_ucred, rc = -ENOMEM);
531
532         hal->hal_version = HAL_VERSION;
533         hal->hal_archive_id = hr->hr_archive_id;
534         hal->hal_flags = hr->hr_flags;
535         obd_uuid2fsname(hal->hal_fsname, mdt2obd_dev(info->mti_mdt)->obd_name,
536                         MTI_NAME_MAXLEN);
537
538         hal->hal_count = hr->hr_itemcount;
539         hai = hai_zero(hal);
540         for (i = 0; i < hr->hr_itemcount; i++) {
541                 hai->hai_action = action;
542                 hai->hai_cookie = 0;
543                 hai->hai_gid = 0;
544                 hai->hai_fid = hui[i].hui_fid;
545                 hai->hai_extent = hui[i].hui_extent;
546                 memcpy(hai->hai_data, data, hr->hr_data_len);
547                 hai->hai_len = sizeof(*hai) + hr->hr_data_len;
548                 hai = hai_next(hai);
549         }
550
551         rc = mdt_hsm_coordinator_actions(info, hal, &compound_id, 0);
552         /* ENODATA error code is needed only for implicit requests */
553         if (rc == -ENODATA)
554                 rc = 0;
555
556         MDT_HSM_FREE(hal, hal_size);
557         EXIT;
558 out_ucred:
559         mdt_exit_ucred(info);
560         return rc;
561 }