Whamcloud - gitweb
LU-13543 lustre: update *pos in seq_file .next functions
[fs/lustre-release.git] / lustre / mdt / mdt_hsm_cdt_actions.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  * (C) Copyright 2012 Commissariat a l'energie atomique et aux energies
24  *     alternatives
25  *
26  * Copyright (c) 2013, 2017, Intel Corporation.
27  */
28 /*
29  * lustre/mdt/mdt_hsm_cdt_actions.c
30  *
31  * Lustre HSM
32  *
33  * Author: Jacques-Charles Lafoucriere <jacques-charles.lafoucriere@cea.fr>
34  * Author: Aurelien Degremont <aurelien.degremont@cea.fr>
35  */
36
37 #define DEBUG_SUBSYSTEM S_MDS
38
39 #include <libcfs/libcfs.h>
40 #include <libcfs/libcfs_hash.h>
41 #include <obd_support.h>
42 #include <lustre_export.h>
43 #include <obd.h>
44 #include <lprocfs_status.h>
45 #include <lustre_log.h>
46 #include "mdt_internal.h"
47
48 struct cdt_agent_record_loc {
49         struct hlist_node carl_hnode;
50         atomic_t carl_refcount;
51         u64 carl_cookie;
52         u32 carl_cat_idx;
53         u32 carl_rec_idx;
54 };
55
56 static inline void cdt_agent_record_loc_get(struct cdt_agent_record_loc *carl)
57 {
58         LASSERT(atomic_read(&carl->carl_refcount) > 0);
59         atomic_inc(&carl->carl_refcount);
60 }
61
62 static inline void cdt_agent_record_loc_put(struct cdt_agent_record_loc *carl)
63 {
64         LASSERT(atomic_read(&carl->carl_refcount) > 0);
65         if (atomic_dec_and_test(&carl->carl_refcount))
66                 OBD_FREE_PTR(carl);
67 }
68
69 static unsigned int
70 cdt_agent_record_hash(struct cfs_hash *hs, const void *key, unsigned int mask)
71 {
72         return cfs_hash_djb2_hash(key, sizeof(u64), mask);
73 }
74
75 static void *cdt_agent_record_object(struct hlist_node *hnode)
76 {
77         return hlist_entry(hnode, struct cdt_agent_record_loc, carl_hnode);
78 }
79
80 static void *cdt_agent_record_key(struct hlist_node *hnode)
81 {
82         struct cdt_agent_record_loc *carl = cdt_agent_record_object(hnode);
83
84         return &carl->carl_cookie;
85 }
86
87 static int cdt_agent_record_keycmp(const void *key, struct hlist_node *hnode)
88 {
89         const u64 *cookie2 = cdt_agent_record_key(hnode);
90
91         return *(const u64 *)key == *cookie2;
92 }
93
94 static void cdt_agent_record_get(struct cfs_hash *hs, struct hlist_node *hnode)
95 {
96         struct cdt_agent_record_loc *carl = cdt_agent_record_object(hnode);
97
98         cdt_agent_record_loc_get(carl);
99 }
100
101 static void cdt_agent_record_put(struct cfs_hash *hs, struct hlist_node *hnode)
102 {
103         struct cdt_agent_record_loc *carl = cdt_agent_record_object(hnode);
104
105         cdt_agent_record_loc_put(carl);
106 }
107
108 struct cfs_hash_ops cdt_agent_record_hash_ops = {
109         .hs_hash        = cdt_agent_record_hash,
110         .hs_key         = cdt_agent_record_key,
111         .hs_keycmp      = cdt_agent_record_keycmp,
112         .hs_object      = cdt_agent_record_object,
113         .hs_get         = cdt_agent_record_get,
114         .hs_put_locked  = cdt_agent_record_put,
115 };
116
117 void cdt_agent_record_hash_add(struct coordinator *cdt, u64 cookie, u32 cat_idx,
118                                u32 rec_idx)
119 {
120         struct cdt_agent_record_loc *carl0;
121         struct cdt_agent_record_loc *carl1;
122
123         OBD_ALLOC_PTR(carl1);
124         if (carl1 == NULL)
125                 return;
126
127         INIT_HLIST_NODE(&carl1->carl_hnode);
128         atomic_set(&carl1->carl_refcount, 1);
129         carl1->carl_cookie = cookie;
130         carl1->carl_cat_idx = cat_idx;
131         carl1->carl_rec_idx = rec_idx;
132
133         carl0 = cfs_hash_findadd_unique(cdt->cdt_agent_record_hash,
134                                         &carl1->carl_cookie,
135                                         &carl1->carl_hnode);
136
137         LASSERT(carl0->carl_cookie == carl1->carl_cookie);
138         LASSERT(carl0->carl_cat_idx == carl1->carl_cat_idx);
139         LASSERT(carl0->carl_rec_idx == carl1->carl_rec_idx);
140
141         if (carl0 != carl1)
142                 cdt_agent_record_loc_put(carl0);
143
144         cdt_agent_record_loc_put(carl1);
145 }
146
147 void cdt_agent_record_hash_lookup(struct coordinator *cdt, u64 cookie,
148                                   u32 *cat_idx, u32 *rec_idx)
149 {
150         struct cdt_agent_record_loc *carl;
151
152         carl = cfs_hash_lookup(cdt->cdt_agent_record_hash, &cookie);
153         if (carl != NULL) {
154                 LASSERT(carl->carl_cookie == cookie);
155                 *cat_idx = carl->carl_cat_idx;
156                 *rec_idx = carl->carl_rec_idx;
157                 cdt_agent_record_loc_put(carl);
158         } else {
159                 *cat_idx = 0;
160                 *rec_idx = 0;
161         }
162 }
163
164 void cdt_agent_record_hash_del(struct coordinator *cdt, u64 cookie)
165 {
166         cfs_hash_del_key(cdt->cdt_agent_record_hash, &cookie);
167 }
168
169 void dump_llog_agent_req_rec(const char *prefix,
170                              const struct llog_agent_req_rec *larr)
171 {
172         char    buf[12];
173         int     sz;
174
175         sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai);
176         CDEBUG(D_HSM, "%slrh=[type=%X len=%d idx=%d] fid="DFID
177                " dfid="DFID
178                " cookie=%#llx"
179                " status=%s action=%s archive#=%d flags=%#llx"
180                " create=%llu change=%llu"
181                " extent=%#llx-%#llx gid=%#llx datalen=%d"
182                " data=[%s]\n",
183                prefix,
184                larr->arr_hdr.lrh_type,
185                larr->arr_hdr.lrh_len, larr->arr_hdr.lrh_index,
186                PFID(&larr->arr_hai.hai_fid),
187                PFID(&larr->arr_hai.hai_dfid),
188                larr->arr_hai.hai_cookie,
189                agent_req_status2name(larr->arr_status),
190                hsm_copytool_action2name(larr->arr_hai.hai_action),
191                larr->arr_archive_id,
192                larr->arr_flags,
193                larr->arr_req_create, larr->arr_req_change,
194                larr->arr_hai.hai_extent.offset,
195                larr->arr_hai.hai_extent.length,
196                larr->arr_hai.hai_gid, sz,
197                hai_dump_data_field(&larr->arr_hai, buf, sizeof(buf)));
198 }
199
200 /*
201  * process the actions llog
202  * \param env [IN] environment
203  * \param mdt [IN] MDT device
204  * \param cb [IN] llog callback funtion
205  * \param data [IN] llog callback  data
206  * \param rw [IN] cdt_llog_lock mode (READ or WRITE)
207  * \param start_cat_idx first catalog index to examine
208  * \param start_rec_idx first record index to examine
209  * \retval 0 success
210  * \retval -ve failure
211  */
212 int cdt_llog_process(const struct lu_env *env, struct mdt_device *mdt,
213                      llog_cb_t cb, void *data, u32 start_cat_idx,
214                      u32 start_rec_idx, int rw)
215 {
216         struct obd_device       *obd = mdt2obd_dev(mdt);
217         struct llog_ctxt        *lctxt = NULL;
218         struct coordinator      *cdt = &mdt->mdt_coordinator;
219         int                      rc;
220         ENTRY;
221
222         lctxt = llog_get_context(obd, LLOG_AGENT_ORIG_CTXT);
223         if (lctxt == NULL || lctxt->loc_handle == NULL)
224                 RETURN(-ENOENT);
225
226         if (rw == READ)
227                 down_read(&cdt->cdt_llog_lock);
228         else
229                 down_write(&cdt->cdt_llog_lock);
230
231         rc = llog_cat_process(env, lctxt->loc_handle, cb, data, start_cat_idx,
232                               start_rec_idx);
233         if (rc < 0)
234                 CERROR("%s: failed to process HSM_ACTIONS llog (rc=%d)\n",
235                         mdt_obd_name(mdt), rc);
236         else
237                 rc = 0;
238
239         llog_ctxt_put(lctxt);
240
241         if (rw == READ)
242                 up_read(&cdt->cdt_llog_lock);
243         else
244                 up_write(&cdt->cdt_llog_lock);
245
246         RETURN(rc);
247 }
248
249 /**
250  * add an entry in agent llog
251  * \param env [IN] environment
252  * \param mdt [IN] PDT device
253  * \param archive_id [IN] backend archive number
254  * \param hai [IN] record to register
255  * \retval 0 success
256  * \retval -ve failure
257  */
258 int mdt_agent_record_add(const struct lu_env *env, struct mdt_device *mdt,
259                          __u32 archive_id, __u64 flags,
260                          struct hsm_action_item *hai)
261 {
262         struct obd_device               *obd = mdt2obd_dev(mdt);
263         struct coordinator              *cdt = &mdt->mdt_coordinator;
264         struct llog_ctxt                *lctxt = NULL;
265         struct llog_agent_req_rec       *larr;
266         int                              rc;
267         int                              sz;
268         ENTRY;
269
270         sz = llog_data_len(sizeof(*larr) + hai->hai_len - sizeof(*hai));
271         OBD_ALLOC(larr, sz);
272         if (!larr)
273                 RETURN(-ENOMEM);
274         larr->arr_hdr.lrh_len = sz;
275         larr->arr_hdr.lrh_type = HSM_AGENT_REC;
276         larr->arr_status = ARS_WAITING;
277         larr->arr_archive_id = archive_id;
278         larr->arr_flags = flags;
279         larr->arr_req_create = ktime_get_real_seconds();
280         larr->arr_req_change = larr->arr_req_create;
281         memcpy(&larr->arr_hai, hai, hai->hai_len);
282
283         lctxt = llog_get_context(obd, LLOG_AGENT_ORIG_CTXT);
284         if (lctxt == NULL || lctxt->loc_handle == NULL)
285                 GOTO(free, rc = -ENOENT);
286
287         down_write(&cdt->cdt_llog_lock);
288
289         /* in case of cancel request, the cookie is already set to the
290          * value of the request cookie to be cancelled
291          * so we do not change it */
292         if (hai->hai_action == HSMA_CANCEL)
293                 larr->arr_hai.hai_cookie = hai->hai_cookie;
294         else
295                 larr->arr_hai.hai_cookie = cdt->cdt_last_cookie++;
296
297         rc = llog_cat_add(env, lctxt->loc_handle, &larr->arr_hdr, NULL);
298         if (rc > 0)
299                 rc = 0;
300
301         up_write(&cdt->cdt_llog_lock);
302         llog_ctxt_put(lctxt);
303
304         EXIT;
305 free:
306         OBD_FREE(larr, sz);
307         return rc;
308 }
309
310 /**
311  * data passed to llog_cat_process() callback
312  * to find requests
313  */
314 struct data_update_cb {
315         struct mdt_device       *mdt;
316         struct hsm_record_update *updates;
317         unsigned int             updates_count;
318         unsigned int             updates_done;
319         time64_t                 change_time;
320 };
321
322 /**
323  *  llog_cat_process() callback, used to update a record
324  * \param env [IN] environment
325  * \param llh [IN] llog handle
326  * \param hdr [IN] llog record
327  * \param data [IN] cb data = data_update_cb
328  * \retval 0 success
329  * \retval -ve failure
330  */
331 static int mdt_agent_record_update_cb(const struct lu_env *env,
332                                       struct llog_handle *llh,
333                                       struct llog_rec_hdr *hdr,
334                                       void *data)
335 {
336         struct llog_agent_req_rec       *larr;
337         struct data_update_cb           *ducb;
338         int                              rc, i;
339         ENTRY;
340
341         larr = (struct llog_agent_req_rec *)hdr;
342         ducb = data;
343
344         /* check if all done */
345         if (ducb->updates_count == ducb->updates_done)
346                 RETURN(LLOG_PROC_BREAK);
347
348         /* if record is in final state, never change */
349         if (agent_req_in_final_state(larr->arr_status))
350                 RETURN(0);
351
352         rc = 0;
353         for (i = 0 ; i < ducb->updates_count ; i++) {
354                 struct hsm_record_update *update = &ducb->updates[i];
355
356                 CDEBUG(D_HSM, "%s: search %#llx, found %#llx\n",
357                        mdt_obd_name(ducb->mdt), update->cookie,
358                        larr->arr_hai.hai_cookie);
359                 if (larr->arr_hai.hai_cookie == update->cookie) {
360
361                         /* If record is a cancel request, it cannot be
362                          * canceled. This is to manage the following
363                          * case: when a request is canceled, we have 2
364                          * records with the the same cookie: the one
365                          * to cancel and the cancel request the 1st
366                          * has to be set to ARS_CANCELED and the 2nd
367                          * to ARS_SUCCEED
368                          */
369                         if (larr->arr_hai.hai_action == HSMA_CANCEL &&
370                             update->status == ARS_CANCELED)
371                                 RETURN(0);
372
373                         larr->arr_status = update->status;
374                         larr->arr_req_change = ducb->change_time;
375                         rc = llog_write(env, llh, hdr, hdr->lrh_index);
376                         ducb->updates_done++;
377                         break;
378                 }
379         }
380
381         if (rc < 0)
382                 CERROR("%s: mdt_agent_llog_update_rec() failed, rc = %d\n",
383                        mdt_obd_name(ducb->mdt), rc);
384
385         RETURN(rc);
386 }
387
388 /**
389  * update an entry in agent llog
390  *
391  * \param env [IN] environment
392  * \param mdt [IN] MDT device
393  * \param updates [IN] array of entries to update
394  * \param updates_count [IN] number of entries in updates
395  *
396  * \retval 0 on success
397  * \retval negative on failure
398  */
399 int mdt_agent_record_update(const struct lu_env *env, struct mdt_device *mdt,
400                             struct hsm_record_update *updates,
401                             unsigned int updates_count)
402 {
403         struct data_update_cb    ducb;
404         u32 start_cat_idx = -1;
405         u32 start_rec_idx = -1;
406         u32 cat_idx;
407         u32 rec_idx;
408         int i;
409         int rc;
410         ENTRY;
411
412         /* Find the first location (start_cat_idx, start_rec_idx)
413          * among the records corresponding to cookies. */
414         for (i = 0; i < updates_count; i++) {
415                 /* If we cannot find a cached location for a cookie
416                  * (perhaps because the MDT was restart then we must
417                  * start from the beginning. In this case
418                  * mdt_agent_record_hash_get() sets both of cat_idx and
419                  * rec_idx to 0. */
420                 cdt_agent_record_hash_lookup(&mdt->mdt_coordinator,
421                                              updates[i].cookie,
422                                              &cat_idx, &rec_idx);
423                 if (cat_idx < start_cat_idx) {
424                         start_cat_idx = cat_idx;
425                         start_rec_idx = rec_idx;
426                 } else if (cat_idx == start_cat_idx &&
427                            rec_idx < start_rec_idx) {
428                         start_rec_idx = rec_idx;
429                 }
430         }
431
432         /* Fixup starting record index for llog_cat_process(). */
433         if (start_rec_idx != 0)
434                 start_rec_idx -= 1;
435
436         ducb.mdt = mdt;
437         ducb.updates = updates;
438         ducb.updates_count = updates_count;
439         ducb.updates_done = 0;
440         ducb.change_time = ktime_get_real_seconds();
441
442         rc = cdt_llog_process(env, mdt, mdt_agent_record_update_cb, &ducb,
443                               start_cat_idx, start_rec_idx, WRITE);
444         if (rc < 0)
445                 CERROR("%s: cdt_llog_process() failed, rc=%d, cannot update "
446                        "status for %u cookies, done %u\n",
447                        mdt_obd_name(mdt), rc,
448                        updates_count, ducb.updates_done);
449         RETURN(rc);
450 }
451
452 /*
453  * Agent actions /proc seq_file methods
454  * As llog processing uses a callback for each entry, we cannot do a sequential
455  * read. To limit calls to llog_cat_process (it spawns a thread), we fill
456  * multiple record in seq_file buffer in one show call.
457  * op->start() sets the iterator up and returns the first element of sequence
458  * op->stop() shuts it down.
459  * op->show() iterate llog and print element into the buffer.
460  * In case of error ->start() and ->next() return ERR_PTR(error)
461  * In the end of sequence they return %NULL
462  * op->show() returns 0 in case of success and negative number in case of error.
463  *
464  */
465 /**
466  * seq_file iterator for agent_action entry
467  */
468 #define AGENT_ACTIONS_IT_MAGIC 0x19660426
469 struct agent_action_iterator {
470         int                      aai_magic;      /**< magic number */
471         bool                     aai_eof;        /**< all done */
472         struct lu_env            aai_env;        /**< lustre env for llog */
473         struct mdt_device       *aai_mdt;        /**< metadata device */
474         struct llog_ctxt        *aai_ctxt;       /**< llog context */
475         int                      aai_cat_index;  /**< cata idx already shown */
476         int                      aai_index;      /**< idx in cata shown */
477 };
478
479 /**
480  * seq_file method called to start access to /proc file
481  * get llog context + llog handle
482  */
483 static void *mdt_hsm_actions_debugfs_start(struct seq_file *s, loff_t *pos)
484 {
485         struct agent_action_iterator *aai = s->private;
486
487         ENTRY;
488
489         LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X\n",
490                  aai->aai_magic);
491
492         aai->aai_ctxt = llog_get_context(mdt2obd_dev(aai->aai_mdt),
493                                          LLOG_AGENT_ORIG_CTXT);
494         if (aai->aai_ctxt == NULL || aai->aai_ctxt->loc_handle == NULL) {
495                 CERROR("llog_get_context() failed\n");
496                 RETURN(ERR_PTR(-ENOENT));
497         }
498
499         CDEBUG(D_HSM, "llog successfully initialized, start from %lld\n",
500                *pos);
501         /* first call = rewind */
502         if (*pos == 0) {
503                 aai->aai_cat_index = 0;
504                 aai->aai_index = 0;
505                 aai->aai_eof = false;
506         }
507
508         if (aai->aai_eof)
509                 RETURN(NULL);
510
511         RETURN(aai);
512 }
513
514 static void *mdt_hsm_actions_debugfs_next(struct seq_file *s, void *v,
515                                          loff_t *pos)
516 {
517         struct agent_action_iterator *aai = s->private;
518
519         (*pos)++;
520         if (aai->aai_eof)
521                 RETURN(NULL);
522         RETURN(aai);
523 }
524
525 /**
526  *  llog_cat_process() callback, used to fill a seq_file buffer
527  */
528 static int hsm_actions_show_cb(const struct lu_env *env,
529                                  struct llog_handle *llh,
530                                  struct llog_rec_hdr *hdr,
531                                  void *data)
532 {
533         struct llog_agent_req_rec *larr = (struct llog_agent_req_rec *)hdr;
534         struct seq_file *s = data;
535         struct agent_action_iterator *aai = s->private;
536         int sz;
537         char buf[12];
538
539         ENTRY;
540
541         LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X\n",
542                  aai->aai_magic);
543
544         /* if rec already printed => skip */
545         if (unlikely(llh->lgh_hdr->llh_cat_idx < aai->aai_cat_index))
546                 RETURN(0);
547
548         if (unlikely(llh->lgh_hdr->llh_cat_idx == aai->aai_cat_index &&
549                      hdr->lrh_index <= aai->aai_index))
550                 RETURN(0);
551
552         sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai);
553         seq_printf(s, "lrh=[type=%X len=%d idx=%d/%d] fid="DFID
554                    " dfid="DFID" compound/cookie=%#llx/%#llx"
555                    " action=%s archive#=%d flags=%#llx"
556                    " extent=%#llx-%#llx"
557                    " gid=%#llx datalen=%d status=%s data=[%s]\n",
558                    hdr->lrh_type, hdr->lrh_len,
559                    llh->lgh_hdr->llh_cat_idx, hdr->lrh_index,
560                    PFID(&larr->arr_hai.hai_fid),
561                    PFID(&larr->arr_hai.hai_dfid),
562                    0ULL /* compound_id */, larr->arr_hai.hai_cookie,
563                    hsm_copytool_action2name(larr->arr_hai.hai_action),
564                    larr->arr_archive_id,
565                    larr->arr_flags,
566                    larr->arr_hai.hai_extent.offset,
567                    larr->arr_hai.hai_extent.length,
568                    larr->arr_hai.hai_gid, sz,
569                    agent_req_status2name(larr->arr_status),
570                    hai_dump_data_field(&larr->arr_hai, buf, sizeof(buf)));
571
572         aai->aai_cat_index = llh->lgh_hdr->llh_cat_idx;
573         aai->aai_index = hdr->lrh_index;
574
575         RETURN(0);
576 }
577
578 /**
579  * mdt_hsm_actions_debugfs_show() is called at for each seq record
580  * process the llog, with a cb which fill the file_seq buffer
581  * to be faster, one show will fill multiple records
582  */
583 static int mdt_hsm_actions_debugfs_show(struct seq_file *s, void *v)
584 {
585         struct agent_action_iterator *aai = s->private;
586         struct coordinator *cdt = &aai->aai_mdt->mdt_coordinator;
587         int rc;
588
589         ENTRY;
590
591         LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X\n",
592                  aai->aai_magic);
593
594         CDEBUG(D_HSM, "show from cat %d index %d eof=%d\n",
595                aai->aai_cat_index, aai->aai_index, aai->aai_eof);
596         if (aai->aai_eof)
597                 RETURN(0);
598
599         down_read(&cdt->cdt_llog_lock);
600         rc = llog_cat_process(&aai->aai_env, aai->aai_ctxt->loc_handle,
601                               hsm_actions_show_cb, s,
602                               aai->aai_cat_index, aai->aai_index);
603         up_read(&cdt->cdt_llog_lock);
604         if (rc == 0) /* all llog parsed */
605                 aai->aai_eof = true;
606         if (rc == LLOG_PROC_BREAK) /* buffer full */
607                 rc = 0;
608
609         RETURN(rc);
610 }
611
612 /**
613  * seq_file method called to stop access to /proc file
614  * clean + put llog context
615  */
616 static void mdt_hsm_actions_debugfs_stop(struct seq_file *s, void *v)
617 {
618         struct agent_action_iterator *aai = s->private;
619
620         ENTRY;
621
622         LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X\n",
623                  aai->aai_magic);
624
625         if (aai->aai_ctxt)
626                 llog_ctxt_put(aai->aai_ctxt);
627
628         EXIT;
629 }
630
631 static const struct seq_operations mdt_hsm_actions_debugfs_ops = {
632         .start  = mdt_hsm_actions_debugfs_start,
633         .next   = mdt_hsm_actions_debugfs_next,
634         .show   = mdt_hsm_actions_debugfs_show,
635         .stop   = mdt_hsm_actions_debugfs_stop,
636 };
637
638 static int ldebugfs_open_hsm_actions(struct inode *inode, struct file *file)
639 {
640         struct agent_action_iterator    *aai;
641         struct seq_file                 *s;
642         int                              rc;
643         struct mdt_device               *mdt;
644         ENTRY;
645
646         rc = seq_open(file, &mdt_hsm_actions_debugfs_ops);
647         if (rc)
648                 RETURN(rc);
649
650         OBD_ALLOC_PTR(aai);
651         if (aai == NULL)
652                 GOTO(err, rc = -ENOMEM);
653
654         aai->aai_magic = AGENT_ACTIONS_IT_MAGIC;
655         rc = lu_env_init(&aai->aai_env, LCT_LOCAL);
656         if (rc)
657                 GOTO(err, rc);
658
659         /* mdt is saved in seq_file->data by
660          * mdt_coordinator_tunables_init() calling
661          * debugfs_register()
662          */
663         mdt = inode->i_private;
664         aai->aai_mdt = mdt;
665         s = file->private_data;
666         s->private = aai;
667
668         GOTO(out, rc = 0);
669
670 err:
671         seq_release(inode, file);
672         if (aai && aai->aai_env.le_ses)
673                 OBD_FREE_PTR(aai->aai_env.le_ses);
674         if (aai)
675                 OBD_FREE_PTR(aai);
676 out:
677         return rc;
678 }
679
680 /**
681  * ldebugfs_release_hsm_actions() is called at end of /proc access.
682  * It frees allocated resources and calls cleanup lprocfs methods.
683  */
684 static int ldebugfs_release_hsm_actions(struct inode *inode, struct file *file)
685 {
686         struct seq_file                 *seq = file->private_data;
687         struct agent_action_iterator    *aai = seq->private;
688
689         if (aai) {
690                 lu_env_fini(&aai->aai_env);
691                 OBD_FREE_PTR(aai);
692         }
693
694         return seq_release(inode, file);
695 }
696
697 /* Methods to access HSM action list LLOG through /proc */
698 const struct file_operations mdt_hsm_actions_fops = {
699         .owner          = THIS_MODULE,
700         .open           = ldebugfs_open_hsm_actions,
701         .read           = seq_read,
702         .llseek         = seq_lseek,
703         .release        = ldebugfs_release_hsm_actions,
704 };