4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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.
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
23 * Copyright (c) 2011, 2012 Commissariat a l'energie atomique et aux energies
26 * Copyright (c) 2012, 2014, Intel Corporation.
27 * Use is subject to license terms.
30 * lustre/mdt/mdt_hsm.c
32 * Lustre Metadata Target (mdt) request handler
34 * Author: Aurelien Degremont <aurelien.degremont@cea.fr>
35 * Author: JC Lafoucriere <jacques-charles.lafoucriere@cea.fr>
38 #define DEBUG_SUBSYSTEM S_MDS
40 #include "mdt_internal.h"
42 /* Max allocation to satisfy single HSM RPC. */
43 #define MDT_HSM_ALLOC_MAX (1 << 20)
45 #define MDT_HSM_ALLOC(ptr, size) \
47 if ((size) <= MDT_HSM_ALLOC_MAX) \
48 OBD_ALLOC_LARGE((ptr), (size)); \
53 #define MDT_HSM_FREE(ptr, size) OBD_FREE_LARGE((ptr), (size))
56 * Update on-disk HSM attributes.
58 int mdt_hsm_attr_set(struct mdt_thread_info *info, struct mdt_object *obj,
59 const struct md_hsm *mh)
61 struct md_object *next = mdt_object_child(obj);
62 struct lu_buf *buf = &info->mti_buf;
63 struct hsm_attrs *attrs;
67 attrs = (struct hsm_attrs *)info->mti_xattr_buf;
68 CLASSERT(sizeof(info->mti_xattr_buf) >= sizeof(*attrs));
70 /* pack HSM attributes */
71 lustre_hsm2buf(info->mti_xattr_buf, mh);
73 /* update HSM attributes */
75 buf->lb_len = sizeof(*attrs);
76 rc = mo_xattr_set(info->mti_env, next, buf, XATTR_NAME_HSM, 0);
81 static inline bool mdt_hsm_is_admin(struct mdt_thread_info *info)
86 if (info->mti_body == NULL)
89 rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
93 is_admin = md_capable(mdt_ucred(info), CFS_CAP_SYS_ADMIN);
101 * Extract information coming from a copytool and asks coordinator to update
102 * a request status depending on the update content.
104 * Copytools could use this to report failure in their process.
106 * This is HSM_PROGRESS RPC handler.
108 int mdt_hsm_progress(struct tgt_session_info *tsi)
110 struct mdt_thread_info *info;
111 struct hsm_progress_kernel *hpk;
115 if (tsi->tsi_mdt_body == NULL)
118 hpk = req_capsule_client_get(tsi->tsi_pill, &RMF_MDS_HSM_PROGRESS);
120 RETURN(err_serious(-EPROTO));
122 hpk->hpk_errval = lustre_errno_ntoh(hpk->hpk_errval);
124 CDEBUG(D_HSM, "Progress on "DFID": len="LPU64" err=%d\n",
125 PFID(&hpk->hpk_fid), hpk->hpk_extent.length, hpk->hpk_errval);
128 CDEBUG(D_HSM, "Copytool progress on "DFID" failed (%d); %s.\n",
129 PFID(&hpk->hpk_fid), hpk->hpk_errval,
130 hpk->hpk_flags & HP_FLAG_RETRY ? "will retry" : "fatal");
132 if (hpk->hpk_flags & HP_FLAG_COMPLETED)
133 CDEBUG(D_HSM, "Finished "DFID" (%d) cancel cookie="LPX64"\n",
134 PFID(&hpk->hpk_fid), hpk->hpk_errval, hpk->hpk_cookie);
136 info = tsi2mdt_info(tsi);
137 if (!mdt_hsm_is_admin(info))
138 GOTO(out, rc = -EPERM);
140 rc = mdt_hsm_coordinator_update(info, hpk);
142 mdt_thread_info_fini(info);
146 int mdt_hsm_ct_register(struct tgt_session_info *tsi)
148 struct mdt_thread_info *info;
153 archives = req_capsule_client_get(tsi->tsi_pill, &RMF_MDS_HSM_ARCHIVE);
154 if (archives == NULL)
155 RETURN(err_serious(-EPROTO));
157 info = tsi2mdt_info(tsi);
158 if (!mdt_hsm_is_admin(info))
159 GOTO(out, rc = -EPERM);
161 /* XXX: directly include this function here? */
162 rc = mdt_hsm_agent_register_mask(info, &tsi->tsi_exp->exp_client_uuid,
165 mdt_thread_info_fini(info);
169 int mdt_hsm_ct_unregister(struct tgt_session_info *tsi)
171 struct mdt_thread_info *info;
175 if (tsi->tsi_mdt_body == NULL)
178 info = tsi2mdt_info(tsi);
179 if (!mdt_hsm_is_admin(info))
180 GOTO(out, rc = -EPERM);
182 /* XXX: directly include this function here? */
183 rc = mdt_hsm_agent_unregister(info, &tsi->tsi_exp->exp_client_uuid);
185 mdt_thread_info_fini(info);
190 * Retrieve the current HSM flags, archive id and undergoing HSM requests for
191 * the fid provided in RPC body.
193 * Current requests are read from coordinator states.
195 * This is MDS_HSM_STATE_GET RPC handler.
197 int mdt_hsm_state_get(struct tgt_session_info *tsi)
199 struct mdt_thread_info *info = tsi2mdt_info(tsi);
200 struct mdt_object *obj = info->mti_object;
201 struct md_attr *ma = &info->mti_attr;
202 struct hsm_user_state *hus;
203 struct mdt_lock_handle *lh;
207 if (info->mti_body == NULL || obj == NULL)
208 GOTO(out, rc = -EPROTO);
210 /* Only valid if client is remote */
211 rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
213 GOTO(out, rc = err_serious(rc));
215 lh = &info->mti_lh[MDT_LH_CHILD];
216 mdt_lock_reg_init(lh, LCK_PR);
217 rc = mdt_object_lock(info, obj, lh, MDS_INODELOCK_LOOKUP,
223 ma->ma_need = MA_HSM;
224 rc = mdt_attr_get_complex(info, obj, ma);
226 GOTO(out_unlock, rc);
228 hus = req_capsule_server_get(tsi->tsi_pill, &RMF_HSM_USER_STATE);
230 GOTO(out_unlock, rc = -EPROTO);
232 /* Current HSM flags */
233 hus->hus_states = ma->ma_hsm.mh_flags;
234 hus->hus_archive_id = ma->ma_hsm.mh_arch_id;
238 mdt_object_unlock(info, obj, lh, 1);
240 mdt_exit_ucred(info);
242 mdt_thread_info_fini(info);
247 * Change HSM state and archive number of a file.
249 * Archive number is changed iif the value is not 0.
250 * The new flagset that will be computed should result in a coherent state.
251 * This function checks that flags are compatible.
253 * This is MDS_HSM_STATE_SET RPC handler.
255 int mdt_hsm_state_set(struct tgt_session_info *tsi)
257 struct mdt_thread_info *info = tsi2mdt_info(tsi);
258 struct mdt_object *obj = info->mti_object;
259 struct md_attr *ma = &info->mti_attr;
260 struct hsm_state_set *hss;
261 struct mdt_lock_handle *lh;
266 hss = req_capsule_client_get(info->mti_pill, &RMF_HSM_STATE_SET);
268 if (info->mti_body == NULL || obj == NULL || hss == NULL)
269 GOTO(out, rc = -EPROTO);
271 /* Only valid if client is remote */
272 rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
274 GOTO(out, rc = err_serious(rc));
276 lh = &info->mti_lh[MDT_LH_CHILD];
277 mdt_lock_reg_init(lh, LCK_PW);
278 rc = mdt_object_lock(info, obj, lh, MDS_INODELOCK_LOOKUP |
279 MDS_INODELOCK_XATTR, MDT_LOCAL_LOCK);
283 /* Detect out-of range masks */
284 if ((hss->hss_setmask | hss->hss_clearmask) & ~HSM_FLAGS_MASK) {
285 CDEBUG(D_HSM, "Incompatible masks provided (set "LPX64
286 ", clear "LPX64") vs supported set (%#x).\n",
287 hss->hss_setmask, hss->hss_clearmask, HSM_FLAGS_MASK);
288 GOTO(out_unlock, rc = -EINVAL);
291 /* Non-root users are forbidden to set or clear flags which are
292 * NOT defined in HSM_USER_MASK. */
293 if (((hss->hss_setmask | hss->hss_clearmask) & ~HSM_USER_MASK) &&
294 !md_capable(mdt_ucred(info), CFS_CAP_SYS_ADMIN)) {
295 CDEBUG(D_HSM, "Incompatible masks provided (set "LPX64
296 ", clear "LPX64") vs unprivileged set (%#x).\n",
297 hss->hss_setmask, hss->hss_clearmask, HSM_USER_MASK);
298 GOTO(out_unlock, rc = -EPERM);
301 /* Read current HSM info */
303 ma->ma_need = MA_HSM;
304 rc = mdt_attr_get_complex(info, obj, ma);
306 GOTO(out_unlock, rc);
308 /* Change HSM flags depending on provided masks */
309 if (hss->hss_valid & HSS_SETMASK)
310 ma->ma_hsm.mh_flags |= hss->hss_setmask;
311 if (hss->hss_valid & HSS_CLEARMASK)
312 ma->ma_hsm.mh_flags &= ~hss->hss_clearmask;
314 /* Change archive_id if provided. */
315 if (hss->hss_valid & HSS_ARCHIVE_ID) {
316 if (!(ma->ma_hsm.mh_flags & HS_EXISTS)) {
317 CDEBUG(D_HSM, "Could not set an archive number for "
318 DFID "if HSM EXISTS flag is not set.\n",
319 PFID(&info->mti_body->mbo_fid1));
320 GOTO(out_unlock, rc);
323 /* Detect out-of range archive id */
324 if (hss->hss_archive_id > LL_HSM_MAX_ARCHIVE) {
325 CDEBUG(D_HSM, "archive id %u exceeds maximum %zu.\n",
326 hss->hss_archive_id, LL_HSM_MAX_ARCHIVE);
327 GOTO(out_unlock, rc = -EINVAL);
330 ma->ma_hsm.mh_arch_id = hss->hss_archive_id;
333 /* Check for inconsistant HSM flagset.
334 * DIRTY without EXISTS: no dirty if no archive was created.
335 * DIRTY and RELEASED: a dirty file could not be released.
336 * RELEASED without ARCHIVED: do not release a non-archived file.
337 * LOST without ARCHIVED: cannot lost a non-archived file.
339 flags = ma->ma_hsm.mh_flags;
340 if ((flags & HS_DIRTY && !(flags & HS_EXISTS)) ||
341 (flags & HS_RELEASED && flags & HS_DIRTY) ||
342 (flags & HS_RELEASED && !(flags & HS_ARCHIVED)) ||
343 (flags & HS_LOST && !(flags & HS_ARCHIVED))) {
344 CDEBUG(D_HSM, "Incompatible flag change on "DFID
346 PFID(&info->mti_body->mbo_fid1), flags);
347 GOTO(out_unlock, rc = -EINVAL);
350 /* Save the modified flags */
351 rc = mdt_hsm_attr_set(info, obj, &ma->ma_hsm);
353 GOTO(out_unlock, rc);
358 mdt_object_unlock(info, obj, lh, 1);
360 mdt_exit_ucred(info);
362 mdt_thread_info_fini(info);
367 * Retrieve undergoing HSM requests for the fid provided in RPC body.
368 * Current requests are read from coordinator states.
370 * This is MDS_HSM_ACTION RPC handler.
372 int mdt_hsm_action(struct tgt_session_info *tsi)
374 struct mdt_thread_info *info;
375 struct hsm_current_action *hca;
376 struct hsm_action_list *hal = NULL;
377 struct hsm_action_item *hai;
382 hca = req_capsule_server_get(tsi->tsi_pill,
383 &RMF_MDS_HSM_CURRENT_ACTION);
385 RETURN(err_serious(-EPROTO));
387 if (tsi->tsi_mdt_body == NULL)
390 info = tsi2mdt_info(tsi);
391 /* Only valid if client is remote */
392 rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
394 GOTO(out, rc = err_serious(rc));
396 /* Coordinator information */
397 hal_size = sizeof(*hal) +
398 cfs_size_round(MTI_NAME_MAXLEN) /* fsname */ +
399 cfs_size_round(sizeof(*hai));
401 MDT_HSM_ALLOC(hal, hal_size);
403 GOTO(out_ucred, rc = -ENOMEM);
405 hal->hal_version = HAL_VERSION;
406 hal->hal_archive_id = 0;
408 obd_uuid2fsname(hal->hal_fsname, mdt_obd_name(info->mti_mdt),
411 hai = hai_first(hal);
412 hai->hai_action = HSMA_NONE;
415 hai->hai_fid = info->mti_body->mbo_fid1;
416 hai->hai_len = sizeof(*hai);
418 rc = mdt_hsm_get_actions(info, hal);
422 /* cookie is used to give back request status */
423 if (hai->hai_cookie == 0)
424 hca->hca_state = HPS_WAITING;
426 hca->hca_state = HPS_RUNNING;
428 switch (hai->hai_action) {
430 hca->hca_action = HUA_NONE;
433 hca->hca_action = HUA_ARCHIVE;
436 hca->hca_action = HUA_RESTORE;
439 hca->hca_action = HUA_REMOVE;
442 hca->hca_action = HUA_CANCEL;
445 hca->hca_action = HUA_NONE;
446 CERROR("%s: Unknown hsm action: %d on "DFID"\n",
447 mdt_obd_name(info->mti_mdt),
448 hai->hai_action, PFID(&hai->hai_fid));
452 hca->hca_location = hai->hai_extent;
456 MDT_HSM_FREE(hal, hal_size);
458 mdt_exit_ucred(info);
460 mdt_thread_info_fini(info);
465 * Process the HSM actions described in a struct hsm_user_request.
467 * The action described in hur will be send to coordinator to be saved and
468 * processed later or either handled directly if hur.hur_action is HUA_RELEASE.
470 * This is MDS_HSM_REQUEST RPC handler.
472 int mdt_hsm_request(struct tgt_session_info *tsi)
474 struct mdt_thread_info *info;
475 struct req_capsule *pill = tsi->tsi_pill;
476 struct hsm_request *hr;
477 struct hsm_user_item *hui;
478 struct hsm_action_list *hal;
479 struct hsm_action_item *hai;
483 enum hsm_copytool_action action = HSMA_NONE;
488 hr = req_capsule_client_get(pill, &RMF_MDS_HSM_REQUEST);
489 hui = req_capsule_client_get(pill, &RMF_MDS_HSM_USER_ITEM);
490 data = req_capsule_client_get(pill, &RMF_GENERIC_DATA);
492 if (tsi->tsi_mdt_body == NULL || hr == NULL || hui == NULL || data == NULL)
495 /* Sanity check. Nothing to do with an empty list */
496 if (hr->hr_itemcount == 0)
499 hui_list_size = req_capsule_get_size(pill, &RMF_MDS_HSM_USER_ITEM,
501 if (hui_list_size < hr->hr_itemcount * sizeof(*hui))
504 data_size = req_capsule_get_size(pill, &RMF_GENERIC_DATA, RCL_CLIENT);
505 if (data_size != hr->hr_data_len)
508 info = tsi2mdt_info(tsi);
509 /* Only valid if client is remote */
510 rc = mdt_init_ucred(info, (struct mdt_body *)info->mti_body);
514 switch (hr->hr_action) {
515 /* code to be removed in hsm1_merge and final patch */
517 CERROR("Release action is not working in hsm1_coord\n");
518 GOTO(out_ucred, rc = -EINVAL);
520 /* end of code to be removed */
522 action = HSMA_ARCHIVE;
525 action = HSMA_RESTORE;
528 action = HSMA_REMOVE;
531 action = HSMA_CANCEL;
534 CERROR("Unknown hsm action: %d\n", hr->hr_action);
535 GOTO(out_ucred, rc = -EINVAL);
538 hal_size = sizeof(*hal) + cfs_size_round(MTI_NAME_MAXLEN) /* fsname */ +
539 (sizeof(*hai) + cfs_size_round(hr->hr_data_len)) *
542 MDT_HSM_ALLOC(hal, hal_size);
544 GOTO(out_ucred, rc = -ENOMEM);
546 hal->hal_version = HAL_VERSION;
547 hal->hal_archive_id = hr->hr_archive_id;
548 hal->hal_flags = hr->hr_flags;
549 obd_uuid2fsname(hal->hal_fsname, mdt_obd_name(info->mti_mdt),
552 hal->hal_count = hr->hr_itemcount;
553 hai = hai_first(hal);
554 for (i = 0; i < hr->hr_itemcount; i++, hai = hai_next(hai)) {
555 hai->hai_action = action;
558 hai->hai_fid = hui[i].hui_fid;
559 hai->hai_extent = hui[i].hui_extent;
560 memcpy(hai->hai_data, data, hr->hr_data_len);
561 hai->hai_len = sizeof(*hai) + hr->hr_data_len;
564 rc = mdt_hsm_add_actions(info, hal, &compound_id);
566 MDT_HSM_FREE(hal, hal_size);
571 mdt_exit_ucred(info);
573 mdt_thread_info_fini(info);