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