X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fmdt%2Fmdt_hsm_cdt_actions.c;h=abb3e6a4aaccc12440b2b7dccbe26787dab7a80b;hb=cc6ef11d2f972ebc440013bddda87a536a09750c;hp=37a4da18a4b6762f62296642d8405ad6645a00cb;hpb=612f27788166e2f1153cb5f2c4b4bffba9a42235;p=fs%2Flustre-release.git diff --git a/lustre/mdt/mdt_hsm_cdt_actions.c b/lustre/mdt/mdt_hsm_cdt_actions.c index 37a4da1..abb3e6a 100644 --- a/lustre/mdt/mdt_hsm_cdt_actions.c +++ b/lustre/mdt/mdt_hsm_cdt_actions.c @@ -23,9 +23,10 @@ * (C) Copyright 2012 Commissariat a l'energie atomique et aux energies * alternatives * + * Copyright (c) 2013, 2016, Intel Corporation. */ /* - * lustre/mdt/mdt_agent_actions.c + * lustre/mdt/mdt_hsm_cdt_actions.c * * Lustre HSM * @@ -35,15 +36,138 @@ #define DEBUG_SUBSYSTEM S_MDS +#include +#include #include -#include #include #include #include #include #include "mdt_internal.h" -void dump_llog_agent_req_rec(char *prefix, struct llog_agent_req_rec *larr) +struct cdt_agent_record_loc { + struct hlist_node carl_hnode; + atomic_t carl_refcount; + u64 carl_cookie; + u32 carl_cat_idx; + u32 carl_rec_idx; +}; + +static inline void cdt_agent_record_loc_get(struct cdt_agent_record_loc *carl) +{ + LASSERT(atomic_read(&carl->carl_refcount) > 0); + atomic_inc(&carl->carl_refcount); +} + +static inline void cdt_agent_record_loc_put(struct cdt_agent_record_loc *carl) +{ + LASSERT(atomic_read(&carl->carl_refcount) > 0); + if (atomic_dec_and_test(&carl->carl_refcount)) + OBD_FREE_PTR(carl); +} + +static unsigned int +cdt_agent_record_hash(struct cfs_hash *hs, const void *key, unsigned int mask) +{ + return cfs_hash_djb2_hash(key, sizeof(u64), mask); +} + +static void *cdt_agent_record_object(struct hlist_node *hnode) +{ + return hlist_entry(hnode, struct cdt_agent_record_loc, carl_hnode); +} + +static void *cdt_agent_record_key(struct hlist_node *hnode) +{ + struct cdt_agent_record_loc *carl = cdt_agent_record_object(hnode); + + return &carl->carl_cookie; +} + +static int cdt_agent_record_keycmp(const void *key, struct hlist_node *hnode) +{ + const u64 *cookie2 = cdt_agent_record_key(hnode); + + return *(const u64 *)key == *cookie2; +} + +static void cdt_agent_record_get(struct cfs_hash *hs, struct hlist_node *hnode) +{ + struct cdt_agent_record_loc *carl = cdt_agent_record_object(hnode); + + cdt_agent_record_loc_get(carl); +} + +static void cdt_agent_record_put(struct cfs_hash *hs, struct hlist_node *hnode) +{ + struct cdt_agent_record_loc *carl = cdt_agent_record_object(hnode); + + cdt_agent_record_loc_put(carl); +} + +struct cfs_hash_ops cdt_agent_record_hash_ops = { + .hs_hash = cdt_agent_record_hash, + .hs_key = cdt_agent_record_key, + .hs_keycmp = cdt_agent_record_keycmp, + .hs_object = cdt_agent_record_object, + .hs_get = cdt_agent_record_get, + .hs_put_locked = cdt_agent_record_put, +}; + +void cdt_agent_record_hash_add(struct coordinator *cdt, u64 cookie, u32 cat_idx, + u32 rec_idx) +{ + struct cdt_agent_record_loc *carl0; + struct cdt_agent_record_loc *carl1; + + OBD_ALLOC_PTR(carl1); + if (carl1 == NULL) + return; + + INIT_HLIST_NODE(&carl1->carl_hnode); + atomic_set(&carl1->carl_refcount, 1); + carl1->carl_cookie = cookie; + carl1->carl_cat_idx = cat_idx; + carl1->carl_rec_idx = rec_idx; + + carl0 = cfs_hash_findadd_unique(cdt->cdt_agent_record_hash, + &carl1->carl_cookie, + &carl1->carl_hnode); + + LASSERT(carl0->carl_cookie == carl1->carl_cookie); + LASSERT(carl0->carl_cat_idx == carl1->carl_cat_idx); + LASSERT(carl0->carl_rec_idx == carl1->carl_rec_idx); + + if (carl0 != carl1) + cdt_agent_record_loc_put(carl0); + + cdt_agent_record_loc_put(carl1); +} + +void cdt_agent_record_hash_lookup(struct coordinator *cdt, u64 cookie, + u32 *cat_idx, u32 *rec_idx) +{ + struct cdt_agent_record_loc *carl; + + carl = cfs_hash_lookup(cdt->cdt_agent_record_hash, &cookie); + if (carl != NULL) { + LASSERT(carl->carl_cookie == cookie); + *cat_idx = carl->carl_cat_idx; + *rec_idx = carl->carl_rec_idx; + cdt_agent_record_loc_put(carl); + } else { + *cat_idx = 0; + *rec_idx = 0; + } +} + +void cdt_agent_record_hash_del(struct coordinator *cdt, u64 cookie) +{ + cfs_hash_del_key(cdt->cdt_agent_record_hash, &cookie); +} + +void dump_llog_agent_req_rec(const char *prefix, + const struct llog_agent_req_rec *larr) { char buf[12]; int sz; @@ -51,10 +175,10 @@ void dump_llog_agent_req_rec(char *prefix, struct llog_agent_req_rec *larr) sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai); CDEBUG(D_HSM, "%slrh=[type=%X len=%d idx=%d] fid="DFID " dfid="DFID - " compound/cookie="LPX64"/"LPX64 - " status=%s action=%s archive#=%d flags="LPX64 - " create="LPU64" change="LPU64 - " extent="LPX64"-"LPX64" gid="LPX64" datalen=%d" + " compound/cookie=%#llx/%#llx" + " status=%s action=%s archive#=%d flags=%#llx" + " create=%llu change=%llu" + " extent=%#llx-%#llx gid=%#llx datalen=%d" " data=[%s]\n", prefix, larr->arr_hdr.lrh_type, @@ -79,11 +203,15 @@ void dump_llog_agent_req_rec(char *prefix, struct llog_agent_req_rec *larr) * \param mdt [IN] MDT device * \param cb [IN] llog callback funtion * \param data [IN] llog callback data + * \param rw [IN] cdt_llog_lock mode (READ or WRITE) + * \param start_cat_idx first catalog index to examine + * \param start_rec_idx first record index to examine * \retval 0 success * \retval -ve failure */ int cdt_llog_process(const struct lu_env *env, struct mdt_device *mdt, - llog_cb_t cb, void *data) + llog_cb_t cb, void *data, u32 start_cat_idx, + u32 start_rec_idx, int rw) { struct obd_device *obd = mdt2obd_dev(mdt); struct llog_ctxt *lctxt = NULL; @@ -92,12 +220,16 @@ int cdt_llog_process(const struct lu_env *env, struct mdt_device *mdt, ENTRY; lctxt = llog_get_context(obd, LLOG_AGENT_ORIG_CTXT); - if ((lctxt == NULL) || (lctxt->loc_handle == NULL)) + if (lctxt == NULL || lctxt->loc_handle == NULL) RETURN(-ENOENT); - down(&cdt->cdt_llog_lock); + if (rw == READ) + down_read(&cdt->cdt_llog_lock); + else + down_write(&cdt->cdt_llog_lock); - rc = llog_cat_process(env, lctxt->loc_handle, cb, data, 0, 0); + rc = llog_cat_process(env, lctxt->loc_handle, cb, data, start_cat_idx, + start_rec_idx); if (rc < 0) CERROR("%s: failed to process HSM_ACTIONS llog (rc=%d)\n", mdt_obd_name(mdt), rc); @@ -105,7 +237,12 @@ int cdt_llog_process(const struct lu_env *env, struct mdt_device *mdt, rc = 0; llog_ctxt_put(lctxt); - up(&cdt->cdt_llog_lock); + + if (rw == READ) + up_read(&cdt->cdt_llog_lock); + else + up_write(&cdt->cdt_llog_lock); + RETURN(rc); } @@ -147,24 +284,26 @@ int mdt_agent_record_add(const struct lu_env *env, memcpy(&larr->arr_hai, hai, hai->hai_len); lctxt = llog_get_context(obd, LLOG_AGENT_ORIG_CTXT); - if ((lctxt == NULL) || (lctxt->loc_handle == NULL)) + if (lctxt == NULL || lctxt->loc_handle == NULL) GOTO(free, rc = -ENOENT); - down(&cdt->cdt_llog_lock); + down_write(&cdt->cdt_llog_lock); /* in case of cancel request, the cookie is already set to the * value of the request cookie to be cancelled * so we do not change it */ - if (hai->hai_action != HSMA_CANCEL) { + if (hai->hai_action == HSMA_CANCEL) { + larr->arr_hai.hai_cookie = hai->hai_cookie; + } else { cdt->cdt_last_cookie++; - hai->hai_cookie = cdt->cdt_last_cookie; + larr->arr_hai.hai_cookie = cdt->cdt_last_cookie; } - larr->arr_hai.hai_cookie = hai->hai_cookie; - rc = llog_cat_add(env, lctxt->loc_handle, &larr->arr_hdr, NULL, NULL); + + rc = llog_cat_add(env, lctxt->loc_handle, &larr->arr_hdr, NULL); if (rc > 0) rc = 0; - up(&cdt->cdt_llog_lock); + up_write(&cdt->cdt_llog_lock); llog_ctxt_put(lctxt); EXIT; @@ -203,12 +342,10 @@ static int mdt_agent_record_update_cb(const struct lu_env *env, struct llog_agent_req_rec *larr; struct data_update_cb *ducb; int rc, i; - int found; ENTRY; larr = (struct llog_agent_req_rec *)hdr; ducb = data; - found = 0; /* check if all done */ if (ducb->cookies_count == ducb->cookies_done) @@ -222,23 +359,21 @@ static int mdt_agent_record_update_cb(const struct lu_env *env, * the 1st has to be set to ARS_CANCELED and the 2nd to ARS_SUCCEED */ if (agent_req_in_final_state(larr->arr_status) || - ((larr->arr_hai.hai_action == HSMA_CANCEL) && - (ducb->status == ARS_CANCELED))) + (larr->arr_hai.hai_action == HSMA_CANCEL && + ducb->status == ARS_CANCELED)) RETURN(0); rc = 0; for (i = 0 ; i < ducb->cookies_count ; i++) { - CDEBUG(D_HSM, "%s: search "LPX64", found "LPX64"\n", + CDEBUG(D_HSM, "%s: search %#llx, found %#llx\n", mdt_obd_name(ducb->mdt), ducb->cookies[i], larr->arr_hai.hai_cookie); if (larr->arr_hai.hai_cookie == ducb->cookies[i]) { larr->arr_status = ducb->status; larr->arr_req_change = ducb->change_time; - rc = mdt_agent_llog_update_rec(env, ducb->mdt, llh, - larr); + rc = llog_write(env, llh, hdr, hdr->lrh_index); ducb->cookies_done++; - found = 1; break; } } @@ -247,9 +382,6 @@ static int mdt_agent_record_update_cb(const struct lu_env *env, CERROR("%s: mdt_agent_llog_update_rec() failed, rc = %d\n", mdt_obd_name(ducb->mdt), rc); - if (found == 1) - RETURN(LLOG_DEL_RECORD); - RETURN(rc); } @@ -268,9 +400,37 @@ int mdt_agent_record_update(const struct lu_env *env, struct mdt_device *mdt, enum agent_req_status status) { struct data_update_cb ducb; - int rc; + u32 start_cat_idx = -1; + u32 start_rec_idx = -1; + u32 cat_idx; + u32 rec_idx; + int i; + int rc; ENTRY; + /* Find the first location (start_cat_idx, start_rec_idx) + * among the records corresponding to cookies. */ + for (i = 0; i < cookies_count; i++) { + /* If we cannot find a cached location for a cookie + * (perhaps because the MDT was restart then we must + * start from the beginning. In this case + * mdt_agent_record_hash_get() sets both of cat_idx and + * rec_idx to 0. */ + cdt_agent_record_hash_lookup(&mdt->mdt_coordinator, cookies[i], + &cat_idx, &rec_idx); + if (cat_idx < start_cat_idx) { + start_cat_idx = cat_idx; + start_rec_idx = rec_idx; + } else if (cat_idx == start_cat_idx && + rec_idx < start_rec_idx) { + start_rec_idx = rec_idx; + } + } + + /* Fixup starting record index for llog_cat_process(). */ + if (start_rec_idx != 0) + start_rec_idx -= 1; + ducb.mdt = mdt; ducb.cookies = cookies; ducb.cookies_count = cookies_count; @@ -278,7 +438,8 @@ int mdt_agent_record_update(const struct lu_env *env, struct mdt_device *mdt, ducb.status = status; ducb.change_time = cfs_time_current_sec(); - rc = cdt_llog_process(env, mdt, mdt_agent_record_update_cb, &ducb); + rc = cdt_llog_process(env, mdt, mdt_agent_record_update_cb, &ducb, + start_cat_idx, start_rec_idx, WRITE); if (rc < 0) CERROR("%s: cdt_llog_process() failed, rc=%d, cannot update " "status to %s for %d cookies, done %d\n", @@ -288,35 +449,6 @@ int mdt_agent_record_update(const struct lu_env *env, struct mdt_device *mdt, RETURN(rc); } -/** - * update a llog record - * cdt_llog_lock must be hold - * \param env [IN] environment - * \param mdt [IN] mdt device - * \param llh [IN] llog handle, must be a catalog handle - * \param larr [IN] record - * \retval 0 success - * \retval -ve failure - */ -int mdt_agent_llog_update_rec(const struct lu_env *env, - struct mdt_device *mdt, struct llog_handle *llh, - struct llog_agent_req_rec *larr) -{ - struct llog_rec_hdr saved_hdr; - int rc; - ENTRY; - - /* saved old record info */ - saved_hdr = larr->arr_hdr; - /* add new record with updated values */ - larr->arr_hdr.lrh_id = 0; - larr->arr_hdr.lrh_index = 0; - rc = llog_cat_add(env, llh->u.phd.phd_cat_handle, &larr->arr_hdr, - NULL, NULL); - larr->arr_hdr = saved_hdr; - RETURN(rc); -} - /* * Agent actions /proc seq_file methods * As llog processing uses a callback for each entry, we cannot do a sequential @@ -324,8 +456,7 @@ int mdt_agent_llog_update_rec(const struct lu_env *env, * multiple record in seq_file buffer in one show call. * op->start() sets the iterator up and returns the first element of sequence * op->stop() shuts it down. - * op->next() returns the next element of sequence. - * op->show() prints element into the buffer. + * op->show() iterate llog and print element into the buffer. * In case of error ->start() and ->next() return ERR_PTR(error) * In the end of sequence they return %NULL * op->show() returns 0 in case of success and negative number in case of error. @@ -337,92 +468,59 @@ int mdt_agent_llog_update_rec(const struct lu_env *env, #define AGENT_ACTIONS_IT_MAGIC 0x19660426 struct agent_action_iterator { int aai_magic; /**< magic number */ + bool aai_eof; /**< all done */ struct lu_env aai_env; /**< lustre env for llog */ - struct obd_device *aai_obd; /**< metadata device */ + struct mdt_device *aai_mdt; /**< metadata device */ struct llog_ctxt *aai_ctxt; /**< llog context */ - struct llog_handle *aai_llh; /**< llog handle */ - int aai_index_done; /**< idx already shown */ - int aai_index_cb; /**< current idx in loop cb */ - int aai_eof; /**< all done */ + int aai_cat_index; /**< cata idx already shown */ + int aai_index; /**< idx in cata shown */ }; /** * seq_file method called to start access to /proc file * get llog context + llog handle */ -static void *mdt_agent_actions_proc_start(struct seq_file *s, loff_t *pos) +static void *mdt_hsm_actions_proc_start(struct seq_file *s, loff_t *pos) { struct agent_action_iterator *aai = s->private; - int rc; ENTRY; - LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X", + LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X\n", aai->aai_magic); - aai->aai_ctxt = llog_get_context(aai->aai_obd, LLOG_AGENT_ORIG_CTXT); - if (aai->aai_ctxt == NULL) { + aai->aai_ctxt = llog_get_context(mdt2obd_dev(aai->aai_mdt), + LLOG_AGENT_ORIG_CTXT); + if (aai->aai_ctxt == NULL || aai->aai_ctxt->loc_handle == NULL) { CERROR("llog_get_context() failed\n"); RETURN(ERR_PTR(-ENOENT)); } - rc = llog_open(&aai->aai_env, aai->aai_ctxt, &aai->aai_llh, NULL, - HSM_ACTIONS, LLOG_OPEN_EXISTS); - if (rc) - GOTO(err, rc); - - rc = llog_init_handle(&aai->aai_env, aai->aai_llh, LLOG_F_IS_CAT, NULL); - if (rc) - GOTO(err, rc); - CDEBUG(D_HSM, "llog succesfully initialized, start from "LPD64"\n", + CDEBUG(D_HSM, "llog successfully initialized, start from %lld\n", *pos); /* first call = rewind */ if (*pos == 0) { - aai->aai_index_done = 0; - aai->aai_eof = 0; + aai->aai_cat_index = 0; + aai->aai_index = 0; + aai->aai_eof = false; *pos = 1; } - RETURN(aai); -err: - if (aai->aai_llh) { - llog_cat_close(&aai->aai_env, aai->aai_llh); - aai->aai_llh = NULL; - } - - if (aai->aai_ctxt) - llog_ctxt_put(aai->aai_ctxt); + if (aai->aai_eof) + RETURN(NULL); - RETURN(ERR_PTR(rc)); + RETURN(aai); } -/** - * seq_file method called to get next item - * just returns NULL at eof - * (seq_file buffer filling is done in llog_cat_process() callback) - */ -static void *mdt_agent_actions_proc_next(struct seq_file *s, void *v, +static void *mdt_hsm_actions_proc_next(struct seq_file *s, void *v, loff_t *pos) { - struct agent_action_iterator *aai = s->private; - ENTRY; - - LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X", - aai->aai_magic); - - CDEBUG(D_HSM, "set current="LPD64" to done=%d, eof=%d\n", - *pos, aai->aai_index_done, aai->aai_eof); - (*pos) = aai->aai_index_done; - - if (aai->aai_eof) - RETURN(NULL); - - RETURN(aai); + RETURN(NULL); } /** * llog_cat_process() callback, used to fill a seq_file buffer */ -static int agent_actions_show_cb(const struct lu_env *env, +static int hsm_actions_show_cb(const struct lu_env *env, struct llog_handle *llh, struct llog_rec_hdr *hdr, void *data) @@ -430,77 +528,77 @@ static int agent_actions_show_cb(const struct lu_env *env, struct llog_agent_req_rec *larr = (struct llog_agent_req_rec *)hdr; struct seq_file *s = data; struct agent_action_iterator *aai; - int rc, sz; + int sz; char buf[12]; ENTRY; aai = s->private; - LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X", + LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X\n", aai->aai_magic); - aai->aai_index_cb++; /* if rec already printed => skip */ - if (aai->aai_index_cb <= aai->aai_index_done) + if (unlikely(llh->lgh_hdr->llh_cat_idx < aai->aai_cat_index)) RETURN(0); - sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai); - rc = seq_printf(s, "lrh=[type=%X len=%d idx=%d] fid="DFID - " dfid="DFID - " compound/cookie="LPX64"/"LPX64 - " action=%s archive#=%d flags="LPX64 - " extent="LPX64"-"LPX64 - " gid="LPX64" datalen=%d status=%s" - " data=[%s]\n", - larr->arr_hdr.lrh_type, - larr->arr_hdr.lrh_len, larr->arr_hdr.lrh_index, - PFID(&larr->arr_hai.hai_fid), - PFID(&larr->arr_hai.hai_dfid), - larr->arr_compound_id, larr->arr_hai.hai_cookie, - hsm_copytool_action2name(larr->arr_hai.hai_action), - larr->arr_archive_id, - larr->arr_flags, - larr->arr_hai.hai_extent.offset, - larr->arr_hai.hai_extent.length, - larr->arr_hai.hai_gid, sz, - agent_req_status2name(larr->arr_status), - hai_dump_data_field(&larr->arr_hai, buf, sizeof(buf))); - if (rc >= 0) { - aai->aai_index_done++; + if (unlikely(llh->lgh_hdr->llh_cat_idx == aai->aai_cat_index && + hdr->lrh_index <= aai->aai_index)) RETURN(0); - } - /* buffer is full, stop filling */ - RETURN(LLOG_PROC_BREAK); + + sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai); + seq_printf(s, "lrh=[type=%X len=%d idx=%d/%d] fid="DFID + " dfid="DFID" compound/cookie=%#llx/%#llx" + " action=%s archive#=%d flags=%#llx" + " extent=%#llx-%#llx" + " gid=%#llx datalen=%d status=%s data=[%s]\n", + hdr->lrh_type, hdr->lrh_len, + llh->lgh_hdr->llh_cat_idx, hdr->lrh_index, + PFID(&larr->arr_hai.hai_fid), + PFID(&larr->arr_hai.hai_dfid), + larr->arr_compound_id, larr->arr_hai.hai_cookie, + hsm_copytool_action2name(larr->arr_hai.hai_action), + larr->arr_archive_id, + larr->arr_flags, + larr->arr_hai.hai_extent.offset, + larr->arr_hai.hai_extent.length, + larr->arr_hai.hai_gid, sz, + agent_req_status2name(larr->arr_status), + hai_dump_data_field(&larr->arr_hai, buf, sizeof(buf))); + + aai->aai_cat_index = llh->lgh_hdr->llh_cat_idx; + aai->aai_index = hdr->lrh_index; + + RETURN(0); } /** - * mdt_agent_actions_proc_show() is called at for each seq record + * mdt_hsm_actions_proc_show() is called at for each seq record * process the llog, with a cb which fill the file_seq buffer * to be faster, one show will fill multiple records */ -static int mdt_agent_actions_proc_show(struct seq_file *s, void *v) +static int mdt_hsm_actions_proc_show(struct seq_file *s, void *v) { struct agent_action_iterator *aai = s->private; + struct coordinator *cdt = &aai->aai_mdt->mdt_coordinator; int rc; ENTRY; - LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X", + LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X\n", aai->aai_magic); - CDEBUG(D_HSM, "show from done=%d, eof=%d\n", - aai->aai_index_done, aai->aai_eof); + CDEBUG(D_HSM, "show from cat %d index %d eof=%d\n", + aai->aai_cat_index, aai->aai_index, aai->aai_eof); if (aai->aai_eof) RETURN(0); - aai->aai_index_cb = 0; - rc = llog_cat_process(&aai->aai_env, aai->aai_llh, - agent_actions_show_cb, s, 0, 0); - /* was all llog parsed? */ - if (rc == 0) - aai->aai_eof = 1; - /* not enough room in buffer? */ - if (rc == LLOG_PROC_BREAK) - RETURN(0); - /* error */ + down_read(&cdt->cdt_llog_lock); + rc = llog_cat_process(&aai->aai_env, aai->aai_ctxt->loc_handle, + hsm_actions_show_cb, s, + aai->aai_cat_index, aai->aai_index); + up_read(&cdt->cdt_llog_lock); + if (rc == 0) /* all llog parsed */ + aai->aai_eof = true; + if (rc == LLOG_PROC_BREAK) /* buffer full */ + rc = 0; RETURN(rc); } @@ -508,32 +606,29 @@ static int mdt_agent_actions_proc_show(struct seq_file *s, void *v) * seq_file method called to stop access to /proc file * clean + put llog context */ -static void mdt_agent_actions_proc_stop(struct seq_file *s, void *v) +static void mdt_hsm_actions_proc_stop(struct seq_file *s, void *v) { struct agent_action_iterator *aai = s->private; ENTRY; - LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X", + LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X\n", aai->aai_magic); - if (aai->aai_llh) { - llog_cat_close(&aai->aai_env, aai->aai_llh); - aai->aai_llh = NULL; - } if (aai->aai_ctxt) llog_ctxt_put(aai->aai_ctxt); + EXIT; return; } -static const struct seq_operations mdt_agent_actions_proc_ops = { - .start = mdt_agent_actions_proc_start, - .next = mdt_agent_actions_proc_next, - .show = mdt_agent_actions_proc_show, - .stop = mdt_agent_actions_proc_stop, +static const struct seq_operations mdt_hsm_actions_proc_ops = { + .start = mdt_hsm_actions_proc_start, + .next = mdt_hsm_actions_proc_next, + .show = mdt_hsm_actions_proc_show, + .stop = mdt_hsm_actions_proc_stop, }; -static int lprocfs_open_agent_actions(struct inode *inode, struct file *file) +static int lprocfs_open_hsm_actions(struct inode *inode, struct file *file) { struct agent_action_iterator *aai; struct seq_file *s; @@ -541,14 +636,9 @@ static int lprocfs_open_agent_actions(struct inode *inode, struct file *file) struct mdt_device *mdt; ENTRY; - if (LPROCFS_ENTRY_AND_CHECK(PDE(inode))) - RETURN(-ENOENT); - - rc = seq_open(file, &mdt_agent_actions_proc_ops); - if (rc) { - LPROCFS_EXIT(); + rc = seq_open(file, &mdt_hsm_actions_proc_ops); + if (rc) RETURN(rc); - } OBD_ALLOC_PTR(aai); if (aai == NULL) @@ -559,12 +649,11 @@ static int lprocfs_open_agent_actions(struct inode *inode, struct file *file) if (rc) GOTO(err, rc); - aai->aai_llh = NULL; /* mdt is saved in proc_dir_entry->data by * mdt_coordinator_procfs_init() calling lprocfs_register() */ - mdt = (struct mdt_device *)PDE(inode)->data; - aai->aai_obd = mdt2obd_dev(mdt); + mdt = (struct mdt_device *)PDE_DATA(inode); + aai->aai_mdt = mdt; s = file->private_data; s->private = aai; @@ -581,10 +670,10 @@ out: } /** - * lprocfs_release_agent_actions() is called at end of /proc access - * free alloacted ressources and call cleanup lprocfs methods + * lprocfs_release_hsm_actions() is called at end of /proc access. + * It frees allocated resources and calls cleanup lprocfs methods. */ -static int lprocfs_release_agent_actions(struct inode *inode, struct file *file) +static int lprocfs_release_hsm_actions(struct inode *inode, struct file *file) { struct seq_file *seq = file->private_data; struct agent_action_iterator *aai = seq->private; @@ -597,12 +686,12 @@ static int lprocfs_release_agent_actions(struct inode *inode, struct file *file) return lprocfs_seq_release(inode, file); } -/* methods to access agent actions llog through /proc */ -const struct file_operations mdt_agent_actions_fops = { +/* Methods to access HSM action list LLOG through /proc */ +const struct file_operations mdt_hsm_actions_fops = { .owner = THIS_MODULE, - .open = lprocfs_open_agent_actions, + .open = lprocfs_open_hsm_actions, .read = seq_read, .llseek = seq_lseek, - .release = lprocfs_release_agent_actions, + .release = lprocfs_release_hsm_actions, };