Whamcloud - gitweb
eda547efaaa6217ba8d1ec0f1f20702efc376c02
[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  */
27 /*
28  * lustre/mdt/mdt_hsm_cdt_actions.c
29  *
30  * Lustre HSM
31  *
32  * Author: Jacques-Charles Lafoucriere <jacques-charles.lafoucriere@cea.fr>
33  * Author: Aurelien Degremont <aurelien.degremont@cea.fr>
34  */
35
36 #define DEBUG_SUBSYSTEM S_MDS
37
38 #include <obd_support.h>
39 #include <lustre_net.h>
40 #include <lustre_export.h>
41 #include <obd.h>
42 #include <lprocfs_status.h>
43 #include <lustre_log.h>
44 #include "mdt_internal.h"
45
46 void dump_llog_agent_req_rec(const char *prefix,
47                              const struct llog_agent_req_rec *larr)
48 {
49         char    buf[12];
50         int     sz;
51
52         sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai);
53         CDEBUG(D_HSM, "%slrh=[type=%X len=%d idx=%d] fid="DFID
54                " dfid="DFID
55                " compound/cookie="LPX64"/"LPX64
56                " status=%s action=%s archive#=%d flags="LPX64
57                " create="LPU64" change="LPU64
58                " extent="LPX64"-"LPX64" gid="LPX64" datalen=%d"
59                " data=[%s]\n",
60                prefix,
61                larr->arr_hdr.lrh_type,
62                larr->arr_hdr.lrh_len, larr->arr_hdr.lrh_index,
63                PFID(&larr->arr_hai.hai_fid),
64                PFID(&larr->arr_hai.hai_dfid),
65                larr->arr_compound_id, larr->arr_hai.hai_cookie,
66                agent_req_status2name(larr->arr_status),
67                hsm_copytool_action2name(larr->arr_hai.hai_action),
68                larr->arr_archive_id,
69                larr->arr_flags,
70                larr->arr_req_create, larr->arr_req_change,
71                larr->arr_hai.hai_extent.offset,
72                larr->arr_hai.hai_extent.length,
73                larr->arr_hai.hai_gid, sz,
74                hai_dump_data_field(&larr->arr_hai, buf, sizeof(buf)));
75 }
76
77 /*
78  * process the actions llog
79  * \param env [IN] environment
80  * \param mdt [IN] MDT device
81  * \param cb [IN] llog callback funtion
82  * \param data [IN] llog callback  data
83  * \retval 0 success
84  * \retval -ve failure
85  */
86 int cdt_llog_process(const struct lu_env *env, struct mdt_device *mdt,
87                      llog_cb_t cb, void *data)
88 {
89         struct obd_device       *obd = mdt2obd_dev(mdt);
90         struct llog_ctxt        *lctxt = NULL;
91         struct coordinator      *cdt = &mdt->mdt_coordinator;
92         int                      rc;
93         ENTRY;
94
95         lctxt = llog_get_context(obd, LLOG_AGENT_ORIG_CTXT);
96         if (lctxt == NULL || lctxt->loc_handle == NULL)
97                 RETURN(-ENOENT);
98
99         mutex_lock(&cdt->cdt_llog_lock);
100
101         rc = llog_cat_process(env, lctxt->loc_handle, cb, data, 0, 0);
102         if (rc < 0)
103                 CERROR("%s: failed to process HSM_ACTIONS llog (rc=%d)\n",
104                         mdt_obd_name(mdt), rc);
105         else
106                 rc = 0;
107
108         llog_ctxt_put(lctxt);
109         mutex_unlock(&cdt->cdt_llog_lock);
110         RETURN(rc);
111 }
112
113 /**
114  * add an entry in agent llog
115  * \param env [IN] environment
116  * \param mdt [IN] PDT device
117  * \param compound_id [IN] global id associated with the record
118  * \param archive_id [IN] backend archive number
119  * \param hai [IN] record to register
120  * \retval 0 success
121  * \retval -ve failure
122  */
123 int mdt_agent_record_add(const struct lu_env *env,
124                          struct mdt_device *mdt,
125                          __u64 compound_id, __u32 archive_id,
126                          __u64 flags, struct hsm_action_item *hai)
127 {
128         struct obd_device               *obd = mdt2obd_dev(mdt);
129         struct coordinator              *cdt = &mdt->mdt_coordinator;
130         struct llog_ctxt                *lctxt = NULL;
131         struct llog_agent_req_rec       *larr;
132         int                              rc;
133         int                              sz;
134         ENTRY;
135
136         sz = llog_data_len(sizeof(*larr) + hai->hai_len - sizeof(*hai));
137         OBD_ALLOC(larr, sz);
138         if (!larr)
139                 RETURN(-ENOMEM);
140         larr->arr_hdr.lrh_len = sz;
141         larr->arr_hdr.lrh_type = HSM_AGENT_REC;
142         larr->arr_status = ARS_WAITING;
143         larr->arr_compound_id = compound_id;
144         larr->arr_archive_id = archive_id;
145         larr->arr_flags = flags;
146         larr->arr_req_create = cfs_time_current_sec();
147         larr->arr_req_change = larr->arr_req_create;
148         memcpy(&larr->arr_hai, hai, hai->hai_len);
149
150         lctxt = llog_get_context(obd, LLOG_AGENT_ORIG_CTXT);
151         if (lctxt == NULL || lctxt->loc_handle == NULL)
152                 GOTO(free, rc = -ENOENT);
153
154         mutex_lock(&cdt->cdt_llog_lock);
155
156         /* in case of cancel request, the cookie is already set to the
157          * value of the request cookie to be cancelled
158          * so we do not change it */
159         if (hai->hai_action != HSMA_CANCEL) {
160                 cdt->cdt_last_cookie++;
161                 hai->hai_cookie = cdt->cdt_last_cookie;
162         }
163         larr->arr_hai.hai_cookie = hai->hai_cookie;
164         rc = llog_cat_add(env, lctxt->loc_handle, &larr->arr_hdr, NULL, NULL);
165         if (rc > 0)
166                 rc = 0;
167
168         mutex_unlock(&cdt->cdt_llog_lock);
169         llog_ctxt_put(lctxt);
170
171         EXIT;
172 free:
173         OBD_FREE(larr, sz);
174         return rc;
175 }
176
177 /**
178  * data passed to llog_cat_process() callback
179  * to find requests
180  */
181 struct data_update_cb {
182         struct mdt_device       *mdt;
183         __u64                   *cookies;
184         int                      cookies_count;
185         int                      cookies_done;
186         enum agent_req_status    status;
187         cfs_time_t               change_time;
188 };
189
190 /**
191  *  llog_cat_process() callback, used to update a record
192  * \param env [IN] environment
193  * \param llh [IN] llog handle
194  * \param hdr [IN] llog record
195  * \param data [IN] cb data = data_update_cb
196  * \retval 0 success
197  * \retval -ve failure
198  */
199 static int mdt_agent_record_update_cb(const struct lu_env *env,
200                                       struct llog_handle *llh,
201                                       struct llog_rec_hdr *hdr,
202                                       void *data)
203 {
204         struct llog_agent_req_rec       *larr;
205         struct data_update_cb           *ducb;
206         int                              rc, i;
207         int                              found;
208         ENTRY;
209
210         larr = (struct llog_agent_req_rec *)hdr;
211         ducb = data;
212         found = 0;
213
214         /* check if all done */
215         if (ducb->cookies_count == ducb->cookies_done)
216                 RETURN(LLOG_PROC_BREAK);
217
218         /* if record is in final state, never change */
219         /* if record is a cancel request, it cannot be canceled
220          * this is to manage the following case:
221          * when a request is canceled, we have 2 records with the
222          * the same cookie : the one to cancel and the cancel request
223          * the 1st has to be set to ARS_CANCELED and the 2nd to ARS_SUCCEED
224          */
225         if (agent_req_in_final_state(larr->arr_status) ||
226             (larr->arr_hai.hai_action == HSMA_CANCEL &&
227              ducb->status == ARS_CANCELED))
228                 RETURN(0);
229
230         rc = 0;
231         for (i = 0 ; i < ducb->cookies_count ; i++) {
232                 CDEBUG(D_HSM, "%s: search "LPX64", found "LPX64"\n",
233                        mdt_obd_name(ducb->mdt), ducb->cookies[i],
234                        larr->arr_hai.hai_cookie);
235                 if (larr->arr_hai.hai_cookie == ducb->cookies[i]) {
236
237                         larr->arr_status = ducb->status;
238                         larr->arr_req_change = ducb->change_time;
239                         rc = mdt_agent_llog_update_rec(env, ducb->mdt, llh,
240                                                        larr);
241                         ducb->cookies_done++;
242                         found = 1;
243                         break;
244                 }
245         }
246
247         if (rc < 0)
248                 CERROR("%s: mdt_agent_llog_update_rec() failed, rc = %d\n",
249                        mdt_obd_name(ducb->mdt), rc);
250
251         if (found == 1)
252                 RETURN(LLOG_DEL_RECORD);
253
254         RETURN(rc);
255 }
256
257 /**
258  * update an entry in agent llog
259  * \param env [IN] environment
260  * \param mdt [IN] MDT device
261  * \param cookie [IN] entries to update
262  *    log cookie are returned by register
263  * \param status [IN] new status of the request
264  * \retval 0 success
265  * \retval -ve failure
266  */
267 int mdt_agent_record_update(const struct lu_env *env, struct mdt_device *mdt,
268                             __u64 *cookies, int cookies_count,
269                             enum agent_req_status status)
270 {
271         struct data_update_cb    ducb;
272         int                      rc;
273         ENTRY;
274
275         ducb.mdt = mdt;
276         ducb.cookies = cookies;
277         ducb.cookies_count = cookies_count;
278         ducb.cookies_done = 0;
279         ducb.status = status;
280         ducb.change_time = cfs_time_current_sec();
281
282         rc = cdt_llog_process(env, mdt, mdt_agent_record_update_cb, &ducb);
283         if (rc < 0)
284                 CERROR("%s: cdt_llog_process() failed, rc=%d, cannot update "
285                        "status to %s for %d cookies, done %d\n",
286                        mdt_obd_name(mdt), rc,
287                        agent_req_status2name(status),
288                        cookies_count, ducb.cookies_done);
289         RETURN(rc);
290 }
291
292 /**
293  * update a llog record
294  *  cdt_llog_lock must be hold
295  * \param env [IN] environment
296  * \param mdt [IN] mdt device
297  * \param llh [IN] llog handle, must be a catalog handle
298  * \param larr [IN] record
299  * \retval 0 success
300  * \retval -ve failure
301  */
302 int mdt_agent_llog_update_rec(const struct lu_env *env,
303                               struct mdt_device *mdt, struct llog_handle *llh,
304                               struct llog_agent_req_rec *larr)
305 {
306         struct llog_rec_hdr      saved_hdr;
307         int                      rc;
308         ENTRY;
309
310         /* saved old record info */
311         saved_hdr = larr->arr_hdr;
312         /* add new record with updated values */
313         larr->arr_hdr.lrh_id = 0;
314         larr->arr_hdr.lrh_index = 0;
315         rc = llog_cat_add(env, llh->u.phd.phd_cat_handle, &larr->arr_hdr,
316                           NULL, NULL);
317         larr->arr_hdr = saved_hdr;
318         RETURN(rc);
319 }
320
321 /*
322  * Agent actions /proc seq_file methods
323  * As llog processing uses a callback for each entry, we cannot do a sequential
324  * read. To limit calls to llog_cat_process (it spawns a thread), we fill
325  * multiple record in seq_file buffer in one show call.
326  * op->start() sets the iterator up and returns the first element of sequence
327  * op->stop() shuts it down.
328  * op->show() iterate llog and print element into the buffer.
329  * In case of error ->start() and ->next() return ERR_PTR(error)
330  * In the end of sequence they return %NULL
331  * op->show() returns 0 in case of success and negative number in case of error.
332  *
333  */
334 /**
335  * seq_file iterator for agent_action entry
336  */
337 #define AGENT_ACTIONS_IT_MAGIC 0x19660426
338 struct agent_action_iterator {
339         int                      aai_magic;      /**< magic number */
340         bool                     aai_eof;        /**< all done */
341         struct lu_env            aai_env;        /**< lustre env for llog */
342         struct obd_device       *aai_obd;        /**< metadata device */
343         struct llog_ctxt        *aai_ctxt;       /**< llog context */
344         int                      aai_cat_index;  /**< cata idx already shown */
345         int                      aai_index;      /**< idx in cata shown */
346 };
347
348 /**
349  * seq_file method called to start access to /proc file
350  * get llog context + llog handle
351  */
352 static void *mdt_hsm_actions_proc_start(struct seq_file *s, loff_t *pos)
353 {
354         struct agent_action_iterator    *aai = s->private;
355         ENTRY;
356
357         LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X",
358                  aai->aai_magic);
359
360         aai->aai_ctxt = llog_get_context(aai->aai_obd, LLOG_AGENT_ORIG_CTXT);
361         if (aai->aai_ctxt == NULL || aai->aai_ctxt->loc_handle == NULL) {
362                 CERROR("llog_get_context() failed\n");
363                 RETURN(ERR_PTR(-ENOENT));
364         }
365
366         CDEBUG(D_HSM, "llog succesfully initialized, start from "LPD64"\n",
367                *pos);
368         /* first call = rewind */
369         if (*pos == 0) {
370                 aai->aai_cat_index = 0;
371                 aai->aai_index = 0;
372                 aai->aai_eof = false;
373                 *pos = 1;
374         }
375
376         if (aai->aai_eof)
377                 RETURN(NULL);
378
379         RETURN(aai);
380 }
381
382 static void *mdt_hsm_actions_proc_next(struct seq_file *s, void *v,
383                                          loff_t *pos)
384 {
385         RETURN(NULL);
386 }
387
388 /**
389  *  llog_cat_process() callback, used to fill a seq_file buffer
390  */
391 static int hsm_actions_show_cb(const struct lu_env *env,
392                                  struct llog_handle *llh,
393                                  struct llog_rec_hdr *hdr,
394                                  void *data)
395 {
396         struct llog_agent_req_rec    *larr = (struct llog_agent_req_rec *)hdr;
397         struct seq_file              *s = data;
398         struct agent_action_iterator *aai;
399         int                           rc, sz;
400         size_t                        count;
401         char                          buf[12];
402         ENTRY;
403
404         aai = s->private;
405         LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X",
406                  aai->aai_magic);
407
408         /* if rec already printed => skip */
409         if (unlikely(llh->lgh_hdr->llh_cat_idx < aai->aai_cat_index))
410                 RETURN(0);
411
412         if (unlikely(llh->lgh_hdr->llh_cat_idx == aai->aai_cat_index &&
413                      hdr->lrh_index <= aai->aai_index))
414                 RETURN(0);
415
416         count = s->count;
417         sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai);
418         rc = seq_printf(s, "lrh=[type=%X len=%d idx=%d/%d] fid="DFID
419                         " dfid="DFID
420                         " compound/cookie="LPX64"/"LPX64
421                         " action=%s archive#=%d flags="LPX64
422                         " extent="LPX64"-"LPX64
423                         " gid="LPX64" datalen=%d status=%s"
424                         " data=[%s]\n",
425                         hdr->lrh_type, hdr->lrh_len,
426                         llh->lgh_hdr->llh_cat_idx, hdr->lrh_index,
427                         PFID(&larr->arr_hai.hai_fid),
428                         PFID(&larr->arr_hai.hai_dfid),
429                         larr->arr_compound_id, larr->arr_hai.hai_cookie,
430                         hsm_copytool_action2name(larr->arr_hai.hai_action),
431                         larr->arr_archive_id,
432                         larr->arr_flags,
433                         larr->arr_hai.hai_extent.offset,
434                         larr->arr_hai.hai_extent.length,
435                         larr->arr_hai.hai_gid, sz,
436                         agent_req_status2name(larr->arr_status),
437                         hai_dump_data_field(&larr->arr_hai, buf, sizeof(buf)));
438         if (rc == 0) {
439                 aai->aai_cat_index = llh->lgh_hdr->llh_cat_idx;
440                 aai->aai_index = hdr->lrh_index;
441         } else {
442                 if (s->count == s->size && count > 0) /* rewind the buffer */
443                         s->count = count;
444                 rc = LLOG_PROC_BREAK;
445         }
446         RETURN(rc);
447 }
448
449 /**
450  * mdt_hsm_actions_proc_show() is called at for each seq record
451  * process the llog, with a cb which fill the file_seq buffer
452  * to be faster, one show will fill multiple records
453  */
454 static int mdt_hsm_actions_proc_show(struct seq_file *s, void *v)
455 {
456         struct agent_action_iterator    *aai = s->private;
457         int                              rc;
458         ENTRY;
459
460         LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X",
461                  aai->aai_magic);
462
463         CDEBUG(D_HSM, "show from cat %d index %d eof=%d\n",
464                aai->aai_cat_index, aai->aai_index, aai->aai_eof);
465         if (aai->aai_eof)
466                 RETURN(0);
467
468         rc = llog_cat_process(&aai->aai_env, aai->aai_ctxt->loc_handle,
469                               hsm_actions_show_cb, s,
470                               aai->aai_cat_index, aai->aai_index + 1);
471         if (rc == 0) /* all llog parsed */
472                 aai->aai_eof = true;
473         if (rc == LLOG_PROC_BREAK) /* buffer full */
474                 rc = 0;
475         RETURN(rc);
476 }
477
478 /**
479  * seq_file method called to stop access to /proc file
480  * clean + put llog context
481  */
482 static void mdt_hsm_actions_proc_stop(struct seq_file *s, void *v)
483 {
484         struct agent_action_iterator *aai = s->private;
485         ENTRY;
486
487         LASSERTF(aai->aai_magic == AGENT_ACTIONS_IT_MAGIC, "%08X",
488                  aai->aai_magic);
489
490         if (aai->aai_ctxt)
491                 llog_ctxt_put(aai->aai_ctxt);
492
493         EXIT;
494         return;
495 }
496
497 static const struct seq_operations mdt_hsm_actions_proc_ops = {
498         .start  = mdt_hsm_actions_proc_start,
499         .next   = mdt_hsm_actions_proc_next,
500         .show   = mdt_hsm_actions_proc_show,
501         .stop   = mdt_hsm_actions_proc_stop,
502 };
503
504 static int lprocfs_open_hsm_actions(struct inode *inode, struct file *file)
505 {
506         struct agent_action_iterator    *aai;
507         struct seq_file                 *s;
508         int                              rc;
509         struct mdt_device               *mdt;
510         ENTRY;
511
512         if (LPROCFS_ENTRY_CHECK(PDE(inode)))
513                 RETURN(-ENOENT);
514
515         rc = seq_open(file, &mdt_hsm_actions_proc_ops);
516         if (rc)
517                 RETURN(rc);
518
519         OBD_ALLOC_PTR(aai);
520         if (aai == NULL)
521                 GOTO(err, rc = -ENOMEM);
522
523         aai->aai_magic = AGENT_ACTIONS_IT_MAGIC;
524         rc = lu_env_init(&aai->aai_env, LCT_LOCAL);
525         if (rc)
526                 GOTO(err, rc);
527
528         /* mdt is saved in proc_dir_entry->data by
529          * mdt_coordinator_procfs_init() calling lprocfs_register()
530          */
531         mdt = (struct mdt_device *)PDE(inode)->data;
532         aai->aai_obd = mdt2obd_dev(mdt);
533         s = file->private_data;
534         s->private = aai;
535
536         GOTO(out, rc = 0);
537
538 err:
539         lprocfs_seq_release(inode, file);
540         if (aai && aai->aai_env.le_ses)
541                 OBD_FREE_PTR(aai->aai_env.le_ses);
542         if (aai)
543                 OBD_FREE_PTR(aai);
544 out:
545         return rc;
546 }
547
548 /**
549  * lprocfs_release_hsm_actions() is called at end of /proc access.
550  * It frees allocated ressources and calls cleanup lprocfs methods.
551  */
552 static int lprocfs_release_hsm_actions(struct inode *inode, struct file *file)
553 {
554         struct seq_file                 *seq = file->private_data;
555         struct agent_action_iterator    *aai = seq->private;
556
557         if (aai) {
558                 lu_env_fini(&aai->aai_env);
559                 OBD_FREE_PTR(aai);
560         }
561
562         return lprocfs_seq_release(inode, file);
563 }
564
565 /* Methods to access HSM action list LLOG through /proc */
566 const struct file_operations mdt_hsm_actions_fops = {
567         .owner          = THIS_MODULE,
568         .open           = lprocfs_open_hsm_actions,
569         .read           = seq_read,
570         .llseek         = seq_lseek,
571         .release        = lprocfs_release_hsm_actions,
572 };
573