struct hsm_action_item *hai;
char buf[12];
- CDEBUG(level, "%s: HAL header: version %X count %d compound %#llx"
+ CDEBUG(level, "%s: HAL header: version %X count %d"
" archive_id %d flags %#llx\n",
prefix, hal->hal_version, hal->hal_count,
- hal->hal_compound_id, hal->hal_archive_id, hal->hal_flags);
+ hal->hal_archive_id, hal->hal_flags);
hai = hai_first(hal);
for (i = 0; i < hal->hal_count; i++) {
sz = hai->hai_len - sizeof(*hai);
CDEBUG(level, "%s %d: fid="DFID" dfid="DFID
- " compound/cookie=%#llx/%#llx"
+ " cookie=%#llx"
" action=%s extent=%#llx-%#llx gid=%#llx"
" datalen=%d data=[%s]\n",
prefix, i,
PFID(&hai->hai_fid), PFID(&hai->hai_dfid),
- hal->hal_compound_id, hai->hai_cookie,
+ hai->hai_cookie,
hsm_copytool_action2name(hai->hai_action),
hai->hai_extent.offset,
hai->hai_extent.length,
* for new work?
*/
bool hsd_housekeeping;
+ bool hsd_one_restore;
int hsd_action_count;
int hsd_request_len; /* array alloc len */
int hsd_request_count; /* array used count */
struct coordinator *cdt = &mdt->mdt_coordinator;
struct hsm_scan_request *request;
struct hsm_action_item *hai;
+ size_t hai_size;
+ u32 archive_id;
int i;
/* Are agents full? */
+ if (atomic_read(&cdt->cdt_request_count) >= cdt->cdt_max_requests)
+ RETURN(hsd->hsd_housekeeping ? 0 : LLOG_PROC_BREAK);
+
if (hsd->hsd_action_count + atomic_read(&cdt->cdt_request_count) >=
cdt->cdt_max_requests) {
- if (hsd->hsd_housekeeping) {
- /* Unknown request and no more room for a new
- * request. Continue to scan to find other
- * entries for already existing requests. */
- RETURN(0);
- } else {
- /* We cannot send and more requests, stop
- * here. There might be more known requests
- * that could be merged, but this avoid
- * analyzing too many llogs for minor
- * gains. */
- RETURN(LLOG_PROC_BREAK);
- }
+ /* We cannot send any more request
+ *
+ * *** SPECIAL CASE ***
+ *
+ * Restore requests are too important not to schedule at least
+ * one, everytime we can.
+ */
+ if (larr->arr_hai.hai_action != HSMA_RESTORE ||
+ hsd->hsd_one_restore)
+ RETURN(hsd->hsd_housekeeping ? 0 : LLOG_PROC_BREAK);
}
- /* first search whether the request is found in the list we
- * have built. */
+ hai_size = cfs_size_round(larr->arr_hai.hai_len);
+ archive_id = larr->arr_archive_id;
+
+ /* Can we add this action to one of the existing HALs in hsd. */
request = NULL;
for (i = 0; i < hsd->hsd_request_count; i++) {
- if (hsd->hsd_request[i].hal->hal_compound_id ==
- larr->arr_compound_id) {
+ if (hsd->hsd_request[i].hal->hal_archive_id == archive_id &&
+ hsd->hsd_request[i].hal_used_sz + hai_size <=
+ LDLM_MAXREQSIZE) {
request = &hsd->hsd_request[i];
break;
}
}
- if (!request) {
- struct hsm_action_list *hal;
+ /* Are we trying to force-schedule a request? */
+ if (hsd->hsd_action_count + atomic_read(&cdt->cdt_request_count) >=
+ cdt->cdt_max_requests) {
+ /* Is there really no compatible hsm_scan_request? */
+ if (!request) {
+ for (i -= 1; i >= 0; i--) {
+ if (hsd->hsd_request[i].hal->hal_archive_id ==
+ archive_id) {
+ request = &hsd->hsd_request[i];
+ break;
+ }
+ }
+ }
+
+ /* Make room for the hai */
+ if (request) {
+ /* Discard the last hai until there is enough space */
+ do {
+ request->hal->hal_count--;
+
+ hai = hai_first(request->hal);
+ for (i = 0; i < request->hal->hal_count; i++)
+ hai = hai_next(hai);
+ request->hal_used_sz -=
+ cfs_size_round(hai->hai_len);
+ hsd->hsd_action_count--;
+ } while (request->hal_used_sz + hai_size >
+ LDLM_MAXREQSIZE);
+ } else if (hsd->hsd_housekeeping) {
+ struct hsm_scan_request *tmp;
+
+ /* Discard the (whole) last hal */
+ hsd->hsd_request_count--;
+ LASSERT(hsd->hsd_request_count >= 0);
+ tmp = &hsd->hsd_request[hsd->hsd_request_count];
+ hsd->hsd_action_count -= tmp->hal->hal_count;
+ LASSERT(hsd->hsd_action_count >= 0);
+ OBD_FREE(tmp->hal, tmp->hal_sz);
+ } else {
+ /* Bailing out, this code path is too hot */
+ RETURN(LLOG_PROC_BREAK);
- if (hsd->hsd_request_count == hsd->hsd_request_len) {
- /* Logic as above. */
- if (hsd->hsd_housekeeping)
- RETURN(0);
- else
- RETURN(LLOG_PROC_BREAK);
}
+ }
+ if (!request) {
+ struct hsm_action_list *hal;
+
+ LASSERT(hsd->hsd_request_count < hsd->hsd_request_len);
request = &hsd->hsd_request[hsd->hsd_request_count];
/* allocates hai vector size just needs to be large
* enough */
request->hal_sz = sizeof(*request->hal) +
- cfs_size_round(MTI_NAME_MAXLEN + 1) +
- 2 * cfs_size_round(larr->arr_hai.hai_len);
- OBD_ALLOC(hal, request->hal_sz);
+ cfs_size_round(MTI_NAME_MAXLEN + 1) + 2 * hai_size;
+ OBD_ALLOC_LARGE(hal, request->hal_sz);
if (!hal)
RETURN(-ENOMEM);
hal->hal_version = HAL_VERSION;
strlcpy(hal->hal_fsname, hsd->hsd_fsname, MTI_NAME_MAXLEN + 1);
- hal->hal_compound_id = larr->arr_compound_id;
hal->hal_archive_id = larr->arr_archive_id;
hal->hal_flags = larr->arr_flags;
hal->hal_count = 0;
request->hal_used_sz = hal_size(hal);
request->hal = hal;
hsd->hsd_request_count++;
- hai = hai_first(hal);
- } else {
- /* request is known */
- /* we check if record archive num is the same as the
- * known request, if not we will serve it in multiple
- * time because we do not know if the agent can serve
- * multiple backend a use case is a compound made of
- * multiple restore where the files are not archived
- * in the same backend */
- if (larr->arr_archive_id != request->hal->hal_archive_id)
- RETURN(0);
+ } else if (request->hal_sz < request->hal_used_sz + hai_size) {
+ /* Not enough room, need an extension */
+ void *hal_buffer;
+ int sz;
- if (request->hal_sz < request->hal_used_sz +
- cfs_size_round(larr->arr_hai.hai_len)) {
- /* Not enough room, need an extension */
- void *hal_buffer;
- int sz;
-
- sz = 2 * request->hal_sz;
- OBD_ALLOC(hal_buffer, sz);
- if (!hal_buffer)
- RETURN(-ENOMEM);
- memcpy(hal_buffer, request->hal, request->hal_used_sz);
- OBD_FREE(request->hal, request->hal_sz);
- request->hal = hal_buffer;
- request->hal_sz = sz;
- }
+ sz = min_t(int, 2 * request->hal_sz, LDLM_MAXREQSIZE);
+ LASSERT(request->hal_used_sz + hai_size < sz);
+
+ OBD_ALLOC_LARGE(hal_buffer, sz);
+ if (!hal_buffer)
+ RETURN(-ENOMEM);
- hai = hai_first(request->hal);
- for (i = 0; i < request->hal->hal_count; i++)
- hai = hai_next(hai);
+ memcpy(hal_buffer, request->hal, request->hal_used_sz);
+ OBD_FREE_LARGE(request->hal, request->hal_sz);
+ request->hal = hal_buffer;
+ request->hal_sz = sz;
}
+ hai = hai_first(request->hal);
+ for (i = 0; i < request->hal->hal_count; i++)
+ hai = hai_next(hai);
+
memcpy(hai, &larr->arr_hai, larr->arr_hai.hai_len);
- hai->hai_cookie = larr->arr_hai.hai_cookie;
- hai->hai_gid = larr->arr_hai.hai_gid;
- request->hal_used_sz += cfs_size_round(hai->hai_len);
+ request->hal_used_sz += hai_size;
request->hal->hal_count++;
hsd->hsd_action_count++;
- if (hai->hai_action != HSMA_CANCEL)
+ switch (hai->hai_action) {
+ case HSMA_CANCEL:
+ break;
+ case HSMA_RESTORE:
+ hsd->hsd_one_restore = true;
+ /* Intentional fallthrough */
+ default:
cdt_agent_record_hash_add(cdt, hai->hai_cookie,
llh->lgh_hdr->llh_cat_idx,
larr->arr_hdr.lrh_index);
+ }
RETURN(0);
}
struct cdt_agent_req *car;
time64_t now = ktime_get_real_seconds();
time64_t last;
- int cl_flags;
+ enum changelog_rec_flags clf_flags;
int rc;
if (!hsd->hsd_housekeeping)
}
/* Emit a changelog record for the failed action.*/
- cl_flags = 0;
- hsm_set_cl_error(&cl_flags, ECANCELED);
+ clf_flags = 0;
+ hsm_set_cl_error(&clf_flags, ECANCELED);
switch (hai->hai_action) {
case HSMA_ARCHIVE:
- hsm_set_cl_event(&cl_flags, HE_ARCHIVE);
+ hsm_set_cl_event(&clf_flags, HE_ARCHIVE);
break;
case HSMA_RESTORE:
- hsm_set_cl_event(&cl_flags, HE_RESTORE);
+ hsm_set_cl_event(&clf_flags, HE_RESTORE);
break;
case HSMA_REMOVE:
- hsm_set_cl_event(&cl_flags, HE_REMOVE);
+ hsm_set_cl_event(&clf_flags, HE_REMOVE);
break;
case HSMA_CANCEL:
- hsm_set_cl_event(&cl_flags, HE_CANCEL);
+ hsm_set_cl_event(&clf_flags, HE_CANCEL);
break;
default:
/* Unknown record type, skip changelog. */
- cl_flags = 0;
+ clf_flags = 0;
break;
}
- if (cl_flags != 0)
- mo_changelog(env, CL_HSM, cl_flags, mdt->mdt_child,
+ if (clf_flags != 0)
+ mo_changelog(env, CL_HSM, clf_flags, mdt->mdt_child,
&hai->hai_fid);
if (hai->hai_action == HSMA_RESTORE)
down_write(&cdt->cdt_agent_lock);
list_for_each_entry_safe(ha, tmp2, &cdt->cdt_agents, ha_list) {
list_del(&ha->ha_list);
+ if (ha->ha_archive_cnt != 0)
+ OBD_FREE(ha->ha_archive_id, ha->ha_archive_cnt *
+ sizeof(*ha->ha_archive_id));
OBD_FREE_PTR(ha);
}
up_write(&cdt->cdt_agent_lock);
hsd.hsd_action_count = 0;
hsd.hsd_request_count = 0;
+ hsd.hsd_one_restore = false;
rc = cdt_llog_process(mti->mti_env, mdt, mdt_coordinator_cb,
&hsd, 0, 0, WRITE);
/* Allocate a temporary array to store the cookies to
* update, and their status. */
updates_sz = updates_cnt * sizeof(*updates);
- OBD_ALLOC(updates, updates_sz);
+ OBD_ALLOC_LARGE(updates, updates_sz);
if (updates == NULL) {
- CERROR("%s: Cannot allocate memory (%d o) "
- "for %d updates\n",
+ CERROR("%s: Cannot allocate memory (%d bytes) "
+ "for %d updates. Too many HSM requests?\n",
mdt_obd_name(mdt), updates_sz, updates_cnt);
- continue;
+ goto clean_cb_alloc;
}
/* here hsd contains a list of requests to be started */
mdt_obd_name(mdt), rc, update_idx);
}
- OBD_FREE(updates, updates_sz);
+ OBD_FREE_LARGE(updates, updates_sz);
clean_cb_alloc:
/* free hal allocated by callback */
for (i = 0; i < hsd.hsd_request_count; i++) {
struct hsm_scan_request *request = &hsd.hsd_request[i];
- OBD_FREE(request->hal, request->hal_sz);
+ OBD_FREE_LARGE(request->hal, request->hal_sz);
}
}
cdt->cdt_policy = CDT_DEFAULT_POLICY;
cdt->cdt_active_req_timeout = 3600;
- /* Initialize cdt_compound_id here to allow its usage for
- * delayed requests from RAoLU policy */
- atomic_set(&cdt->cdt_compound_id, ktime_get_real_seconds());
-
/* by default do not remove archives on last unlink */
cdt->cdt_remove_archive_on_last_unlink = false;
GOTO(out, rc);
}
- car = mdt_cdt_alloc_request(hal->hal_compound_id,
- hal->hal_archive_id, hal->hal_flags,
+ car = mdt_cdt_alloc_request(hal->hal_archive_id, hal->hal_flags,
uuid, hai);
if (IS_ERR(car))
GOTO(out, rc = PTR_ERR(car));
mdt_object_child(obj),
mdt_object_child(dobj),
SWAP_LAYOUTS_MDS_HSM);
-
+ if (rc == 0) {
+ rc = mdt_lsom_downgrade(mti, obj);
+ if (rc)
+ CDEBUG(D_INODE,
+ "%s: File fid="DFID" SOM "
+ "downgrade failed, rc = %d\n",
+ mdt_obd_name(mti->mti_mdt),
+ PFID(mdt_object_fid(obj)), rc);
+ }
out_dobj:
mdt_object_unlock_put(mti, dobj, dlh, 1);
out:
const struct cdt_agent_req *car,
enum agent_req_status *status)
{
- const struct lu_env *env = mti->mti_env;
- struct mdt_device *mdt = mti->mti_mdt;
- struct coordinator *cdt = &mdt->mdt_coordinator;
- struct mdt_object *obj = NULL;
- int cl_flags = 0, rc = 0;
- struct md_hsm mh;
- bool is_mh_changed;
- bool need_changelog = true;
- ENTRY;
+ const struct lu_env *env = mti->mti_env;
+ struct mdt_device *mdt = mti->mti_mdt;
+ struct coordinator *cdt = &mdt->mdt_coordinator;
+ struct mdt_object *obj = NULL;
+ enum changelog_rec_flags clf_flags = 0;
+ struct md_hsm mh;
+ bool is_mh_changed;
+ bool need_changelog = true;
+ int rc = 0;
+ ENTRY;
/* default is to retry */
*status = ARS_WAITING;
mdt_obd_name(mdt),
pgs->hpk_cookie, PFID(&pgs->hpk_fid),
pgs->hpk_errval);
- hsm_set_cl_error(&cl_flags,
- CLF_HSM_ERROVERFLOW);
+ hsm_set_cl_error(&clf_flags, CLF_HSM_ERROVERFLOW);
rc = -EINVAL;
} else {
- hsm_set_cl_error(&cl_flags, pgs->hpk_errval);
+ hsm_set_cl_error(&clf_flags, pgs->hpk_errval);
}
switch (car->car_hai->hai_action) {
case HSMA_ARCHIVE:
- hsm_set_cl_event(&cl_flags, HE_ARCHIVE);
+ hsm_set_cl_event(&clf_flags, HE_ARCHIVE);
break;
case HSMA_RESTORE:
- hsm_set_cl_event(&cl_flags, HE_RESTORE);
+ hsm_set_cl_event(&clf_flags, HE_RESTORE);
break;
case HSMA_REMOVE:
- hsm_set_cl_event(&cl_flags, HE_REMOVE);
+ hsm_set_cl_event(&clf_flags, HE_REMOVE);
break;
case HSMA_CANCEL:
- hsm_set_cl_event(&cl_flags, HE_CANCEL);
+ hsm_set_cl_event(&clf_flags, HE_CANCEL);
CERROR("%s: Failed request %#llx on "DFID
" cannot be a CANCEL\n",
mdt_obd_name(mdt),
*status = ARS_SUCCEED;
switch (car->car_hai->hai_action) {
case HSMA_ARCHIVE:
- hsm_set_cl_event(&cl_flags, HE_ARCHIVE);
+ hsm_set_cl_event(&clf_flags, HE_ARCHIVE);
/* set ARCHIVE keep EXIST and clear LOST and
* DIRTY */
mh.mh_arch_ver = pgs->hpk_data_version;
is_mh_changed = true;
break;
case HSMA_RESTORE:
- hsm_set_cl_event(&cl_flags, HE_RESTORE);
+ hsm_set_cl_event(&clf_flags, HE_RESTORE);
/* do not clear RELEASED and DIRTY here
* this will occur in hsm_swap_layouts()
is_mh_changed = true;
break;
case HSMA_REMOVE:
- hsm_set_cl_event(&cl_flags, HE_REMOVE);
+ hsm_set_cl_event(&clf_flags, HE_REMOVE);
/* clear ARCHIVED EXISTS and LOST */
mh.mh_flags &= ~(HS_ARCHIVED | HS_EXISTS | HS_LOST);
is_mh_changed = true;
break;
case HSMA_CANCEL:
- hsm_set_cl_event(&cl_flags, HE_CANCEL);
+ hsm_set_cl_event(&clf_flags, HE_CANCEL);
CERROR("%s: Successful request %#llx on "DFID" cannot be a CANCEL\n",
mdt_obd_name(mdt),
pgs->hpk_cookie,
* filled
*/
if (rc == 0 && !IS_ERR(obj))
- hsm_set_cl_flags(&cl_flags,
+ hsm_set_cl_flags(&clf_flags,
mh.mh_flags & HS_DIRTY ? CLF_HSM_DIRTY : 0);
/* unlock is done later, after layout lock management */
/* restore special case, need to create ChangeLog record
* before to give back layout lock to avoid concurrent
* file updater to post out of order ChangeLog */
- mo_changelog(env, CL_HSM, cl_flags, mdt->mdt_child,
+ mo_changelog(env, CL_HSM, clf_flags, mdt->mdt_child,
&car->car_hai->hai_fid);
need_changelog = false;
out:
/* always add a ChangeLog record */
if (need_changelog)
- mo_changelog(env, CL_HSM, cl_flags, mdt->mdt_child,
+ mo_changelog(env, CL_HSM, clf_flags, mdt->mdt_child,
&car->car_hai->hai_fid);
if (!IS_ERR(obj))
obd_uuid2fsname(hal->hal_fsname, mdt_obd_name(mdt),
MTI_NAME_MAXLEN);
hal->hal_fsname[MTI_NAME_MAXLEN] = '\0';
- hal->hal_compound_id = car->car_compound_id;
hal->hal_archive_id = car->car_archive_id;
hal->hal_flags = car->car_flags;
hal->hal_count = 0;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff