Whamcloud - gitweb
LU-4287 kernel: kernel update RHEL6.5 [2.6.32-431.3.1.el6]
[fs/lustre-release.git] / lustre / mdt / mdt_hsm_cdt_requests.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_requests.c
29  *
30  * Lustre HSM Coordinator
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/lustre_user.h>
40 #include <lprocfs_status.h>
41 #include "mdt_internal.h"
42
43 /**
44  * dump requests list
45  * \param cdt [IN] coordinator
46  */
47 void dump_requests(char *prefix, struct coordinator *cdt)
48 {
49         struct cdt_agent_req    *car;
50
51         down_read(&cdt->cdt_request_lock);
52         list_for_each_entry(car, &cdt->cdt_requests, car_request_list) {
53                 CDEBUG(D_HSM, "%s fid="DFID" dfid="DFID
54                        " compound/cookie="LPX64"/"LPX64
55                        " action=%s archive#=%d flags="LPX64
56                        " extent="LPX64"-"LPX64
57                        " gid="LPX64" refcount=%d canceled=%d\n",
58                        prefix, PFID(&car->car_hai->hai_fid),
59                        PFID(&car->car_hai->hai_dfid),
60                        car->car_compound_id, car->car_hai->hai_cookie,
61                        hsm_copytool_action2name(car->car_hai->hai_action),
62                        car->car_archive_id, car->car_flags,
63                        car->car_hai->hai_extent.offset,
64                        car->car_hai->hai_extent.length,
65                        car->car_hai->hai_gid,
66                        atomic_read(&car->car_refcount),
67                        car->car_canceled);
68         }
69         up_read(&cdt->cdt_request_lock);
70 }
71
72 struct req_interval_data {
73         struct cdt_req_progress *crp;
74         __u64                    done_sz;
75 };
76
77 /**
78  * interval tree cb, used to go through all the tree of extent done
79  */
80 static enum interval_iter req_interval_cb(struct interval_node *node,
81                                           void *args)
82 {
83         struct req_interval_data        *data;
84         ENTRY;
85
86         data = args;
87         data->done_sz += node->in_extent.end - node->in_extent.start;
88         RETURN(INTERVAL_ITER_CONT);
89 }
90
91 /**
92  * scan the interval tree associated to a request
93  * to compute the amount of work done
94  * \param car [IN] request
95  * \param done_sz [OUT] will be set to the size of work done
96  */
97 void mdt_cdt_get_work_done(struct cdt_agent_req *car, __u64 *done_sz)
98 {
99         struct req_interval_data         rid;
100         struct cdt_req_progress         *crp = &car->car_progress;
101
102         mutex_lock(&crp->crp_lock);
103
104         rid.crp = crp;
105         rid.done_sz = 0;
106         interval_iterate(crp->crp_root, req_interval_cb, &rid);
107         *done_sz = rid.done_sz;
108
109         mutex_unlock(&crp->crp_lock);
110 }
111
112 #define NODE_VECTOR_SZ 256
113 /**
114  * free the interval tree associated to a request
115  */
116 static void mdt_cdt_free_request_tree(struct cdt_req_progress *crp)
117 {
118         struct interval_node    *node, *vn;
119         int                      i;
120         ENTRY;
121
122         mutex_lock(&crp->crp_lock);
123
124         if (crp->crp_max == 0)
125                 goto out;
126
127         /* remove all nodes from tree */
128         for (i = 0 ; i < crp->crp_cnt ; i++) {
129                 vn = crp->crp_node[i / NODE_VECTOR_SZ];
130                 node = &vn[i % NODE_VECTOR_SZ];
131                 interval_erase(node, &crp->crp_root);
132         }
133         /* free all sub vectors */
134         for (i = 0 ; i <= crp->crp_max / NODE_VECTOR_SZ ; i++)
135                 OBD_FREE(crp->crp_node[i],
136                          NODE_VECTOR_SZ * sizeof(crp->crp_node[i][0]));
137
138         /* free main vector */
139         OBD_FREE(crp->crp_node,
140                  sizeof(crp->crp_node[0]) *
141                   (crp->crp_max / NODE_VECTOR_SZ + 1));
142
143         crp->crp_cnt = 0;
144         crp->crp_max = 0;
145 out:
146         mutex_unlock(&crp->crp_lock);
147         EXIT;
148 }
149
150 /**
151  * update data moved information during a request
152  */
153 static int hsm_update_work(struct cdt_req_progress *crp,
154                            const struct hsm_extent *extent)
155 {
156         int                       rc, osz, nsz;
157         struct interval_node    **new_vv;
158         struct interval_node     *v, *node;
159         ENTRY;
160
161         mutex_lock(&crp->crp_lock);
162         /* new node index */
163
164         if (crp->crp_cnt >= crp->crp_max) {
165                 /* no more room */
166                 /* allocate a new vector */
167                 OBD_ALLOC(v, NODE_VECTOR_SZ * sizeof(v[0]));
168                 if (v == NULL)
169                         GOTO(out, rc = -ENOMEM);
170
171                 if (crp->crp_max == 0)
172                         osz = 0;
173                 else
174                         osz = sizeof(new_vv[0]) *
175                               (crp->crp_max / NODE_VECTOR_SZ + 1);
176
177                 nsz = osz + sizeof(new_vv[0]);
178                 /* increase main vector size */
179                 OBD_ALLOC(new_vv, nsz);
180                 if (new_vv == NULL) {
181                         OBD_FREE(v, NODE_VECTOR_SZ * sizeof(v[0]));
182                         GOTO(out, rc = -ENOMEM);
183                 }
184
185                 if (osz == 0) {
186                         crp->crp_max = NODE_VECTOR_SZ - 1;
187                 } else {
188                         memcpy(new_vv, crp->crp_node, osz);
189                         OBD_FREE(crp->crp_node, osz);
190                         crp->crp_max += NODE_VECTOR_SZ;
191                 }
192
193                 crp->crp_node = new_vv;
194                 crp->crp_node[crp->crp_max / NODE_VECTOR_SZ] = v;
195         }
196
197         v = crp->crp_node[crp->crp_cnt / NODE_VECTOR_SZ];
198         node = &v[crp->crp_cnt % NODE_VECTOR_SZ];
199         interval_set(node, extent->offset, extent->offset + extent->length);
200         /* try to insert, if entry already exist ignore the new one
201          * it can happen if ct sends 2 times the same progress */
202         if (interval_insert(node, &crp->crp_root) == NULL)
203                 crp->crp_cnt++;
204
205         rc = 0;
206 out:
207         mutex_unlock(&crp->crp_lock);
208         return rc;
209 }
210
211 /**
212  * init the interval tree associated to a request
213  */
214 static void mdt_cdt_init_request_tree(struct cdt_req_progress *crp)
215 {
216         mutex_init(&crp->crp_lock);
217         crp->crp_root = NULL;
218         crp->crp_cnt = 0;
219         crp->crp_max = 0;
220 }
221
222 /** Allocate/init a agent request and its sub-structures.
223  *
224  * \param compound_id [IN]
225  * \param archive_id [IN]
226  * \param flags [IN]
227  * \param uuid [IN]
228  * \param hai [IN]
229  * \retval car [OUT] success valid structure
230  * \retval car [OUT]
231  */
232 struct cdt_agent_req *mdt_cdt_alloc_request(__u64 compound_id, __u32 archive_id,
233                                             __u64 flags, struct obd_uuid *uuid,
234                                             struct hsm_action_item *hai)
235 {
236         struct cdt_agent_req *car;
237         ENTRY;
238
239         OBD_SLAB_ALLOC_PTR(car, mdt_hsm_car_kmem);
240         if (car == NULL)
241                 RETURN(ERR_PTR(-ENOMEM));
242
243         atomic_set(&car->car_refcount, 1);
244         car->car_compound_id = compound_id;
245         car->car_archive_id = archive_id;
246         car->car_flags = flags;
247         car->car_canceled = 0;
248         car->car_req_start = cfs_time_current_sec();
249         car->car_req_update = car->car_req_start;
250         car->car_uuid = *uuid;
251         OBD_ALLOC(car->car_hai, hai->hai_len);
252         if (car->car_hai == NULL) {
253                 OBD_SLAB_FREE_PTR(car, mdt_hsm_car_kmem);
254                 RETURN(ERR_PTR(-ENOMEM));
255         }
256         memcpy(car->car_hai, hai, hai->hai_len);
257         mdt_cdt_init_request_tree(&car->car_progress);
258
259         RETURN(car);
260 }
261
262 /**
263  * Free a agent request and its sub-structures.
264  *
265  * \param car [IN]  Request to be freed.
266  */
267 void mdt_cdt_free_request(struct cdt_agent_req *car)
268 {
269         mdt_cdt_free_request_tree(&car->car_progress);
270         OBD_FREE(car->car_hai, car->car_hai->hai_len);
271         OBD_SLAB_FREE_PTR(car, mdt_hsm_car_kmem);
272 }
273
274 /**
275  * inc refcount of a request
276  * \param car [IN] request
277  */
278 void mdt_cdt_get_request(struct cdt_agent_req *car)
279 {
280         atomic_inc(&car->car_refcount);
281 }
282
283 /**
284  * dec refcount of a request
285  * free if no more refcount
286  * \param car [IN] request
287  */
288 void mdt_cdt_put_request(struct cdt_agent_req *car)
289 {
290         LASSERT(atomic_read(&car->car_refcount) > 0);
291         if (atomic_dec_and_test(&car->car_refcount))
292                 mdt_cdt_free_request(car);
293 }
294
295 /**
296  * find request in the list by cookie or by fid
297  * lock cdt_request_lock needs to be hold by caller
298  * \param cdt [IN] coordinator
299  * \param cookie [IN] request cookie
300  * \param fid [IN] fid
301  * \retval request pointer or NULL if not found
302  */
303 static struct cdt_agent_req *cdt_find_request_nolock(struct coordinator *cdt,
304                                                      __u64 cookie,
305                                                      const struct lu_fid *fid)
306 {
307         struct cdt_agent_req *car;
308         struct cdt_agent_req *found = NULL;
309         ENTRY;
310
311         list_for_each_entry(car, &cdt->cdt_requests, car_request_list) {
312                 if (car->car_hai->hai_cookie == cookie ||
313                     (fid != NULL && lu_fid_eq(fid, &car->car_hai->hai_fid))) {
314                         mdt_cdt_get_request(car);
315                         found = car;
316                         break;
317                 }
318         }
319
320         RETURN(found);
321 }
322
323 /**
324  * add a request to the list
325  * \param cdt [IN] coordinator
326  * \param car [IN] request
327  * \retval 0 success
328  * \retval -ve failure
329  */
330 int mdt_cdt_add_request(struct coordinator *cdt, struct cdt_agent_req *new_car)
331 {
332         struct cdt_agent_req    *car;
333         ENTRY;
334
335         /* cancel requests are not kept in memory */
336         LASSERT(new_car->car_hai->hai_action != HSMA_CANCEL);
337
338         down_write(&cdt->cdt_request_lock);
339         car = cdt_find_request_nolock(cdt, new_car->car_hai->hai_cookie, NULL);
340         if (car != NULL) {
341                 mdt_cdt_put_request(car);
342                 up_write(&cdt->cdt_request_lock);
343                 RETURN(-EEXIST);
344         }
345
346         list_add_tail(&new_car->car_request_list, &cdt->cdt_requests);
347         up_write(&cdt->cdt_request_lock);
348
349         mdt_hsm_agent_update_statistics(cdt, 0, 0, 1, &new_car->car_uuid);
350
351         atomic_inc(&cdt->cdt_request_count);
352
353         RETURN(0);
354 }
355
356 /**
357  * find request in the list by cookie or by fid
358  * \param cdt [IN] coordinator
359  * \param cookie [IN] request cookie
360  * \param fid [IN] fid
361  * \retval request pointer or NULL if not found
362  */
363 struct cdt_agent_req *mdt_cdt_find_request(struct coordinator *cdt,
364                                            const __u64 cookie,
365                                            const struct lu_fid *fid)
366 {
367         struct cdt_agent_req    *car;
368         ENTRY;
369
370         down_read(&cdt->cdt_request_lock);
371         car = cdt_find_request_nolock(cdt, cookie, fid);
372         up_read(&cdt->cdt_request_lock);
373
374         RETURN(car);
375 }
376
377 /**
378  * remove request from the list
379  * \param cdt [IN] coordinator
380  * \param cookie [IN] request cookie
381  * \retval request pointer
382  */
383 int mdt_cdt_remove_request(struct coordinator *cdt, __u64 cookie)
384 {
385         struct cdt_agent_req *car;
386         ENTRY;
387
388         down_write(&cdt->cdt_request_lock);
389         car = cdt_find_request_nolock(cdt, cookie, NULL);
390         if (car != NULL) {
391                 list_del(&car->car_request_list);
392                 up_write(&cdt->cdt_request_lock);
393
394                 /* reference from cdt_requests list */
395                 mdt_cdt_put_request(car);
396
397                 /* reference from cdt_find_request_nolock() */
398                 mdt_cdt_put_request(car);
399
400                 LASSERT(atomic_read(&cdt->cdt_request_count) >= 1);
401                 atomic_dec(&cdt->cdt_request_count);
402
403                 RETURN(0);
404         }
405         up_write(&cdt->cdt_request_lock);
406
407         RETURN(-ENOENT);
408 }
409
410 /**
411  * update a request in the list
412  * on success, add a ref to the request returned
413  * \param cdt [IN] coordinator
414  * \param pgs [IN] progression (cookie + extent + err)
415  * \retval request pointer
416  * \retval -ve failure
417  */
418 struct cdt_agent_req *mdt_cdt_update_request(struct coordinator *cdt,
419                                           const struct hsm_progress_kernel *pgs)
420 {
421         struct cdt_agent_req    *car;
422         int                      rc;
423         ENTRY;
424
425         car = mdt_cdt_find_request(cdt, pgs->hpk_cookie, NULL);
426         if (car == NULL)
427                 RETURN(ERR_PTR(-ENOENT));
428
429         car->car_req_update = cfs_time_current_sec();
430
431         /* update progress done by copy tool */
432         if (pgs->hpk_errval == 0 && pgs->hpk_extent.length != 0) {
433                 rc = hsm_update_work(&car->car_progress, &pgs->hpk_extent);
434                 if (rc) {
435                         mdt_cdt_put_request(car);
436                         RETURN(ERR_PTR(rc));
437                 }
438         }
439
440         if (pgs->hpk_flags & HP_FLAG_COMPLETED) {
441                 if (pgs->hpk_errval != 0)
442                         mdt_hsm_agent_update_statistics(cdt, 0, 1, 0,
443                                                         &car->car_uuid);
444                 else
445                         mdt_hsm_agent_update_statistics(cdt, 1, 0, 0,
446                                                         &car->car_uuid);
447         }
448         RETURN(car);
449 }
450
451 /**
452  * seq_file method called to start access to /proc file
453  */
454 static void *mdt_hsm_active_requests_proc_start(struct seq_file *s, loff_t *p)
455 {
456         struct mdt_device       *mdt = s->private;
457         struct coordinator      *cdt = &mdt->mdt_coordinator;
458         struct list_head        *pos;
459         loff_t                   i;
460         ENTRY;
461
462         down_read(&cdt->cdt_request_lock);
463
464         if (list_empty(&cdt->cdt_requests))
465                 RETURN(NULL);
466
467         if (*p == 0)
468                 RETURN(SEQ_START_TOKEN);
469
470         i = 0;
471         list_for_each(pos, &cdt->cdt_requests) {
472                 i++;
473                 if (i >= *p)
474                         RETURN(pos);
475         }
476         RETURN(NULL);
477 }
478
479 /**
480  * seq_file method called to get next item
481  * just returns NULL at eof
482  */
483 static void *mdt_hsm_active_requests_proc_next(struct seq_file *s, void *v,
484                                                loff_t *p)
485 {
486         struct mdt_device       *mdt = s->private;
487         struct coordinator      *cdt = &mdt->mdt_coordinator;
488         struct list_head        *pos = v;
489         ENTRY;
490
491         if (pos == SEQ_START_TOKEN)
492                 pos = cdt->cdt_requests.next;
493         else
494                 pos = pos->next;
495
496         (*p)++;
497         if (pos != &cdt->cdt_requests)
498                 RETURN(pos);
499         else
500                 RETURN(NULL);
501 }
502
503 /**
504  * display request data
505  */
506 static int mdt_hsm_active_requests_proc_show(struct seq_file *s, void *v)
507 {
508         struct list_head        *pos = v;
509         struct cdt_agent_req    *car;
510         char                     buf[12];
511         __u64                    data_moved;
512         ENTRY;
513
514         if (pos == SEQ_START_TOKEN)
515                 RETURN(0);
516
517         car = list_entry(pos, struct cdt_agent_req, car_request_list);
518         mdt_cdt_get_work_done(car, &data_moved);
519
520         seq_printf(s, "fid="DFID" dfid="DFID
521                    " compound/cookie="LPX64"/"LPX64
522                    " action=%s archive#=%d flags="LPX64
523                    " extent="LPX64"-"LPX64" gid="LPX64
524                    " data=[%s] canceled=%d uuid=%s done="LPU64"%%\n",
525                    PFID(&car->car_hai->hai_fid),
526                    PFID(&car->car_hai->hai_dfid),
527                    car->car_compound_id, car->car_hai->hai_cookie,
528                    hsm_copytool_action2name(car->car_hai->hai_action),
529                    car->car_archive_id, car->car_flags,
530                    car->car_hai->hai_extent.offset,
531                    car->car_hai->hai_extent.length,
532                    car->car_hai->hai_gid,
533                    hai_dump_data_field(car->car_hai, buf, sizeof(buf)),
534                    car->car_canceled, obd_uuid2str(&car->car_uuid),
535                    data_moved);
536         RETURN(0);
537 }
538
539 /**
540  * seq_file method called to stop access to /proc file
541  */
542 static void mdt_hsm_active_requests_proc_stop(struct seq_file *s, void *v)
543 {
544         struct mdt_device       *mdt = s->private;
545         struct coordinator      *cdt = &mdt->mdt_coordinator;
546         ENTRY;
547
548         up_read(&cdt->cdt_request_lock);
549
550         EXIT;
551 }
552
553 /* hsm agent list proc functions */
554 static const struct seq_operations mdt_hsm_active_requests_proc_ops = {
555         .start          = mdt_hsm_active_requests_proc_start,
556         .next           = mdt_hsm_active_requests_proc_next,
557         .show           = mdt_hsm_active_requests_proc_show,
558         .stop           = mdt_hsm_active_requests_proc_stop,
559 };
560
561 /**
562  * public function called at open of /proc file to get
563  * list of agents
564  */
565 static int lprocfs_open_hsm_active_requests(struct inode *inode,
566                                             struct file *file)
567 {
568         struct seq_file *s;
569         int              rc;
570         ENTRY;
571
572         if (LPROCFS_ENTRY_CHECK(PDE(inode)))
573                 RETURN(-ENOENT);
574
575         rc = seq_open(file, &mdt_hsm_active_requests_proc_ops);
576         if (rc) {
577                 RETURN(rc);
578         }
579         s = file->private_data;
580         s->private = PDE(inode)->data;
581
582         RETURN(rc);
583 }
584
585 /* methods to access hsm request list */
586 const struct file_operations mdt_hsm_active_requests_fops = {
587         .owner          = THIS_MODULE,
588         .open           = lprocfs_open_hsm_active_requests,
589         .read           = seq_read,
590         .llseek         = seq_lseek,
591         .release        = lprocfs_seq_release,
592 };
593