1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Copyright (c) 2001-2003 Cluster File Systems, Inc.
5 * Author: Peter Braam <braam@clusterfs.com>
6 * Author: Andreas Dilger <adilger@clusterfs.com>
8 * This file is part of Lustre, http://www.lustre.org.
10 * Lustre is free software; you can redistribute it and/or
11 * modify it under the terms of version 2 of the GNU General Public
12 * License as published by the Free Software Foundation.
14 * Lustre is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with Lustre; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #include <linux/version.h>
27 #include <linux/module.h>
29 #include <linux/highmem.h>
31 #include <linux/stat.h>
32 #include <linux/sched.h>
33 #include <linux/smp_lock.h>
34 #include <linux/ext2_fs.h>
35 #include <linux/quotaops.h>
36 #include <linux/proc_fs.h>
37 #include <linux/init.h>
38 #include <asm/unistd.h>
40 #define DEBUG_SUBSYSTEM S_ECHO
42 #include <linux/obd_support.h>
43 #include <linux/obd_class.h>
44 #include <linux/obd_echo.h>
45 #include <linux/lustre_debug.h>
46 #include <linux/lustre_dlm.h>
47 #include <linux/lprocfs_status.h>
49 #define ECHO_INIT_OBJID 0x1000000000000000ULL
50 #define ECHO_HANDLE_MAGIC 0xabcd0123fedc9876ULL
52 #define ECHO_OBJECT0_NPAGES 16
53 static struct page *echo_object0_pages[ECHO_OBJECT0_NPAGES];
55 /* should be generic per-obd stats... */
56 struct xprocfs_io_stat {
61 __u64 st_getattr_reqs;
62 __u64 st_setattr_reqs;
64 __u64 st_destroy_reqs;
72 static struct xprocfs_io_stat xprocfs_iostats[NR_CPUS];
73 static struct proc_dir_entry *xprocfs_dir;
75 #define XPROCFS_BUMP_MYCPU_IOSTAT(field, count) \
77 xprocfs_iostats[smp_processor_id()].field += (count); \
80 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
81 #define DECLARE_XPROCFS_SUM_STAT(field) \
83 xprocfs_sum_##field (void) \
88 for (i = 0; i < smp_num_cpus; i++) \
89 stat += xprocfs_iostats[i].field; \
93 DECLARE_XPROCFS_SUM_STAT (st_read_bytes)
94 DECLARE_XPROCFS_SUM_STAT (st_read_reqs)
95 DECLARE_XPROCFS_SUM_STAT (st_write_bytes)
96 DECLARE_XPROCFS_SUM_STAT (st_write_reqs)
97 DECLARE_XPROCFS_SUM_STAT (st_getattr_reqs)
98 DECLARE_XPROCFS_SUM_STAT (st_setattr_reqs)
99 DECLARE_XPROCFS_SUM_STAT (st_create_reqs)
100 DECLARE_XPROCFS_SUM_STAT (st_destroy_reqs)
101 DECLARE_XPROCFS_SUM_STAT (st_statfs_reqs)
102 DECLARE_XPROCFS_SUM_STAT (st_syncfs_reqs)
103 DECLARE_XPROCFS_SUM_STAT (st_open_reqs)
104 DECLARE_XPROCFS_SUM_STAT (st_close_reqs)
105 DECLARE_XPROCFS_SUM_STAT (st_punch_reqs)
109 xprocfs_rd_stat (char *page, char **start, off_t off, int count,
110 int *eof, void *data)
112 long long (*fn)(void) = (long long(*)(void))data;
119 len = snprintf (page, count, "%Ld\n", fn());
126 xprocfs_add_stat(char *name, long long (*fn)(void))
128 struct proc_dir_entry *entry;
130 entry = create_proc_entry (name, S_IFREG|S_IRUGO, xprocfs_dir);
132 CERROR ("Can't add procfs stat %s\n", name);
137 entry->read_proc = xprocfs_rd_stat;
138 entry->write_proc = NULL;
142 xprocfs_init (char *name)
146 snprintf (dirname, sizeof (dirname), "sys/%s", name);
148 xprocfs_dir = proc_mkdir (dirname, NULL);
149 if (xprocfs_dir == NULL) {
150 CERROR ("Can't make procfs dir %s\n", dirname);
154 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
155 xprocfs_add_stat ("read_bytes", xprocfs_sum_st_read_bytes);
156 xprocfs_add_stat ("read_reqs", xprocfs_sum_st_read_reqs);
157 xprocfs_add_stat ("write_bytes", xprocfs_sum_st_write_bytes);
158 xprocfs_add_stat ("write_reqs", xprocfs_sum_st_write_reqs);
159 xprocfs_add_stat ("getattr_reqs", xprocfs_sum_st_getattr_reqs);
160 xprocfs_add_stat ("setattr_reqs", xprocfs_sum_st_setattr_reqs);
161 xprocfs_add_stat ("create_reqs", xprocfs_sum_st_create_reqs);
162 xprocfs_add_stat ("destroy_reqs", xprocfs_sum_st_destroy_reqs);
163 xprocfs_add_stat ("statfs_reqs", xprocfs_sum_st_statfs_reqs);
164 xprocfs_add_stat ("syncfs_reqs", xprocfs_sum_st_syncfs_reqs);
165 xprocfs_add_stat ("open_reqs", xprocfs_sum_st_open_reqs);
166 xprocfs_add_stat ("close_reqs", xprocfs_sum_st_close_reqs);
167 xprocfs_add_stat ("punch_reqs", xprocfs_sum_st_punch_reqs);
171 void xprocfs_fini (void)
173 if (xprocfs_dir == NULL)
176 remove_proc_entry ("read_bytes", xprocfs_dir);
177 remove_proc_entry ("read_reqs", xprocfs_dir);
178 remove_proc_entry ("write_bytes", xprocfs_dir);
179 remove_proc_entry ("write_reqs", xprocfs_dir);
180 remove_proc_entry ("getattr_reqs", xprocfs_dir);
181 remove_proc_entry ("setattr_reqs", xprocfs_dir);
182 remove_proc_entry ("create_reqs", xprocfs_dir);
183 remove_proc_entry ("destroy_reqs", xprocfs_dir);
184 remove_proc_entry ("statfs_reqs", xprocfs_dir);
185 remove_proc_entry ("syncfs_reqs", xprocfs_dir);
186 remove_proc_entry ("open_reqs", xprocfs_dir);
187 remove_proc_entry ("close_reqs", xprocfs_dir);
188 remove_proc_entry ("punch_reqs", xprocfs_dir);
190 remove_proc_entry (xprocfs_dir->name, xprocfs_dir->parent);
194 static int echo_connect(struct lustre_handle *conn, struct obd_device *obd,
195 struct obd_uuid *cluuid)
197 return class_connect(conn, obd, cluuid);
200 static int echo_disconnect(struct lustre_handle *conn, int failover)
202 struct obd_export *exp = class_conn2export(conn);
204 LASSERT (exp != NULL);
206 ldlm_cancel_locks_for_export(exp);
207 class_export_put(exp);
208 return (class_disconnect(conn, failover));
211 static __u64 echo_next_id(struct obd_device *obddev)
215 spin_lock(&obddev->u.echo.eo_lock);
216 id = ++obddev->u.echo.eo_lastino;
217 spin_unlock(&obddev->u.echo.eo_lock);
222 int echo_create(struct lustre_handle *conn, struct obdo *oa,
223 struct lov_stripe_md **ea, struct obd_trans_info *oti)
225 struct obd_device *obd = class_conn2obd(conn);
227 XPROCFS_BUMP_MYCPU_IOSTAT (st_create_reqs, 1);
230 CERROR("invalid client cookie "LPX64"\n", conn->cookie);
234 if (!(oa->o_mode && S_IFMT)) {
235 CERROR("echo obd: no type!\n");
239 if (!(oa->o_valid & OBD_MD_FLTYPE)) {
240 CERROR("invalid o_valid %08x\n", oa->o_valid);
244 oa->o_id = echo_next_id(obd);
245 oa->o_valid = OBD_MD_FLID;
246 atomic_inc(&obd->u.echo.eo_create);
251 int echo_destroy(struct lustre_handle *conn, struct obdo *oa,
252 struct lov_stripe_md *ea, struct obd_trans_info *oti)
254 struct obd_device *obd = class_conn2obd(conn);
256 XPROCFS_BUMP_MYCPU_IOSTAT (st_destroy_reqs, 1);
259 CERROR("invalid client cookie "LPX64"\n", conn->cookie);
263 if (!(oa->o_valid & OBD_MD_FLID)) {
264 CERROR("obdo missing FLID valid flag: %08x\n", oa->o_valid);
268 if (oa->o_id > obd->u.echo.eo_lastino || oa->o_id < ECHO_INIT_OBJID) {
269 CERROR("bad destroy objid: "LPX64"\n", oa->o_id);
273 atomic_inc(&obd->u.echo.eo_destroy);
278 static int echo_open(struct lustre_handle *conn, struct obdo *oa,
279 struct lov_stripe_md *md, struct obd_trans_info *oti,
280 struct obd_client_handle *och)
282 struct lustre_handle *fh = obdo_handle (oa);
283 struct obd_device *obd = class_conn2obd (conn);
285 XPROCFS_BUMP_MYCPU_IOSTAT (st_open_reqs, 1);
288 CERROR("invalid client cookie "LPX64"\n", conn->cookie);
292 if (!(oa->o_valid & OBD_MD_FLID)) {
293 CERROR ("obdo missing FLID valid flag: %08x\n", oa->o_valid);
297 fh->cookie = ECHO_HANDLE_MAGIC;
299 oa->o_valid |= OBD_MD_FLHANDLE;
303 static int echo_close(struct lustre_handle *conn, struct obdo *oa,
304 struct lov_stripe_md *md, struct obd_trans_info *oti)
306 struct lustre_handle *fh = obdo_handle (oa);
307 struct obd_device *obd = class_conn2obd(conn);
309 XPROCFS_BUMP_MYCPU_IOSTAT (st_close_reqs, 1);
312 CERROR("invalid client cookie "LPX64"\n", conn->cookie);
316 if (!(oa->o_valid & OBD_MD_FLHANDLE)) {
317 CERROR("obdo missing FLHANDLE valid flag: %08x\n", oa->o_valid);
321 if (fh->cookie != ECHO_HANDLE_MAGIC) {
322 CERROR ("invalid file handle on close: "LPX64"\n", fh->cookie);
329 static int echo_getattr(struct lustre_handle *conn, struct obdo *oa,
330 struct lov_stripe_md *md)
332 struct obd_device *obd = class_conn2obd(conn);
333 obd_id id = oa->o_id;
335 XPROCFS_BUMP_MYCPU_IOSTAT (st_getattr_reqs, 1);
338 CERROR("invalid client cookie "LPX64"\n", conn->cookie);
342 if (!(oa->o_valid & OBD_MD_FLID)) {
343 CERROR("obdo missing FLID valid flag: %08x\n", oa->o_valid);
347 obdo_cpy_md(oa, &obd->u.echo.oa, oa->o_valid);
353 static int echo_setattr(struct lustre_handle *conn, struct obdo *oa,
354 struct lov_stripe_md *md, struct obd_trans_info *oti)
356 struct obd_device *obd = class_conn2obd(conn);
358 XPROCFS_BUMP_MYCPU_IOSTAT (st_setattr_reqs, 1);
361 CERROR("invalid client cookie "LPX64"\n", conn->cookie);
365 if (!(oa->o_valid & OBD_MD_FLID)) {
366 CERROR("obdo missing FLID valid flag: %08x\n", oa->o_valid);
370 memcpy(&obd->u.echo.oa, oa, sizeof(*oa));
372 atomic_inc(&obd->u.echo.eo_setattr);
377 /* This allows us to verify that desc_private is passed unmolested */
378 #define DESC_PRIV 0x10293847
380 int echo_preprw(int cmd, struct obd_export *export, int objcount,
381 struct obd_ioobj *obj, int niocount, struct niobuf_remote *nb,
382 struct niobuf_local *res, void **desc_private,
383 struct obd_trans_info *oti)
385 struct obd_device *obd;
386 struct niobuf_local *r = res;
391 if ((cmd & OBD_BRW_WRITE) != 0)
392 XPROCFS_BUMP_MYCPU_IOSTAT (st_write_reqs, 1);
394 XPROCFS_BUMP_MYCPU_IOSTAT (st_read_reqs, 1);
396 obd = export->exp_obd;
400 memset(res, 0, sizeof(*res) * niocount);
402 CDEBUG(D_PAGE, "%s %d obdos with %d IOs\n",
403 cmd == OBD_BRW_READ ? "reading" : "writing", objcount, niocount);
405 *desc_private = (void *)DESC_PRIV;
407 for (i = 0; i < objcount; i++, obj++) {
408 int gfp_mask = (obj->ioo_id & 1) ? GFP_HIGHUSER : GFP_KERNEL;
409 int isobj0 = obj->ioo_id == 0;
410 int verify = !isobj0;
413 for (j = 0 ; j < obj->ioo_bufcnt ; j++, nb++, r++) {
416 (nb->offset >> PAGE_SHIFT) < ECHO_OBJECT0_NPAGES) {
417 r->page = echo_object0_pages[nb->offset >>
419 /* Take extra ref so __free_pages() can be called OK */
422 r->page = alloc_pages(gfp_mask, 0);
423 if (r->page == NULL) {
424 CERROR("can't get page %u/%u for id "
426 j, obj->ioo_bufcnt, obj->ioo_id);
427 GOTO(preprw_cleanup, rc = -ENOMEM);
431 atomic_inc(&obd->u.echo.eo_prep);
433 r->offset = nb->offset;
435 LASSERT ((r->offset & (PAGE_SIZE - 1)) + r->len <= PAGE_SIZE);
437 CDEBUG(D_PAGE, "$$$$ get page %p @ "LPU64" for %d\n",
438 r->page, r->offset, r->len);
440 if (cmd == OBD_BRW_READ) {
442 XPROCFS_BUMP_MYCPU_IOSTAT(st_read_bytes,r->len);
444 page_debug_setup(kmap (r->page), r->len,
445 r->offset,obj->ioo_id);
450 XPROCFS_BUMP_MYCPU_IOSTAT(st_write_bytes,
453 page_debug_setup(kmap (r->page), r->len,
461 CDEBUG(D_PAGE, "%d pages allocated after prep\n",
462 atomic_read(&obd->u.echo.eo_prep));
467 /* It is possible that we would rather handle errors by allow
468 * any already-set-up pages to complete, rather than tearing them
469 * all down again. I believe that this is what the in-kernel
470 * prep/commit operations do.
472 CERROR("cleaning up %ld pages (%d obdos)\n", (long)(r - res), objcount);
475 /* NB if this is an 'object0' page, __free_pages will just
476 * lose the extra ref gained above */
477 __free_pages(r->page, 0);
478 atomic_dec(&obd->u.echo.eo_prep);
480 memset(res, 0, sizeof(*res) * niocount);
485 int echo_commitrw(int cmd, struct obd_export *export, int objcount,
486 struct obd_ioobj *obj, int niocount, struct niobuf_local *res,
487 void *desc_private, struct obd_trans_info *oti)
489 struct obd_device *obd;
490 struct niobuf_local *r = res;
491 int i, vrc = 0, rc = 0;
494 obd = export->exp_obd;
498 if ((cmd & OBD_BRW_RWMASK) == OBD_BRW_READ) {
499 CDEBUG(D_PAGE, "reading %d obdos with %d IOs\n",
502 CDEBUG(D_PAGE, "writing %d obdos with %d IOs\n",
506 if (niocount && !r) {
507 CERROR("NULL res niobuf with niocount %d\n", niocount);
511 LASSERT(desc_private == (void *)DESC_PRIV);
513 for (i = 0; i < objcount; i++, obj++) {
514 int verify = obj->ioo_id != 0;
517 for (j = 0 ; j < obj->ioo_bufcnt ; j++, r++) {
518 struct page *page = r->page;
523 if (!page || !(addr = page_address(page)) ||
524 !kern_addr_valid(addr)) {
526 CERROR("bad page objid "LPU64":%p, buf %d/%d\n",
527 obj->ioo_id, page, j, obj->ioo_bufcnt);
529 GOTO(commitrw_cleanup, rc = -EFAULT);
532 CDEBUG(D_PAGE, "$$$$ use page %p, addr %p@"LPU64"\n",
533 r->page, addr, r->offset);
536 vrc = page_debug_check("echo", addr, r->len,
537 r->offset, obj->ioo_id);
538 /* check all the pages always */
539 if (vrc != 0 && rc == 0)
544 /* NB see comment above regarding object0 pages */
545 __free_pages(page, 0);
546 atomic_dec(&obd->u.echo.eo_prep);
549 CDEBUG(D_PAGE, "%d pages remain after commit\n",
550 atomic_read(&obd->u.echo.eo_prep));
554 CERROR("cleaning up %ld pages (%d obdos)\n",
555 niocount - (long)(r - res) - 1, objcount);
556 while (++r < res + niocount) {
557 struct page *page = r->page;
559 /* NB see comment above regarding object0 pages */
560 __free_pages(page, 0);
561 atomic_dec(&obd->u.echo.eo_prep);
566 static int echo_setup(struct obd_device *obddev, obd_count len, void *buf)
570 spin_lock_init(&obddev->u.echo.eo_lock);
571 obddev->u.echo.eo_lastino = ECHO_INIT_OBJID;
573 obddev->obd_namespace =
574 ldlm_namespace_new("echo-tgt", LDLM_NAMESPACE_SERVER);
575 if (obddev->obd_namespace == NULL) {
580 ptlrpc_init_client (LDLM_CB_REQUEST_PORTAL, LDLM_CB_REPLY_PORTAL,
581 "echo_ldlm_cb_client", &obddev->obd_ldlm_client);
585 static int echo_cleanup(struct obd_device *obddev, int force, int failover)
589 ldlm_namespace_free(obddev->obd_namespace);
590 CERROR("%d prep/commitrw pages leaked\n",
591 atomic_read(&obddev->u.echo.eo_prep));
596 int echo_attach(struct obd_device *dev, obd_count len, void *data)
598 struct lprocfs_static_vars lvars;
600 lprocfs_init_vars(&lvars);
601 return lprocfs_obd_attach(dev, lvars.obd_vars);
604 int echo_detach(struct obd_device *dev)
606 return lprocfs_obd_detach(dev);
609 static struct obd_ops echo_obd_ops = {
610 o_owner: THIS_MODULE,
611 o_attach: echo_attach,
612 o_detach: echo_detach,
613 o_connect: echo_connect,
614 o_disconnect: echo_disconnect,
615 o_create: echo_create,
616 o_destroy: echo_destroy,
619 o_getattr: echo_getattr,
620 o_setattr: echo_setattr,
621 o_preprw: echo_preprw,
622 o_commitrw: echo_commitrw,
624 o_cleanup: echo_cleanup
627 extern int echo_client_init(void);
628 extern void echo_client_cleanup(void);
631 echo_object0_pages_fini (void)
635 for (i = 0; i < ECHO_OBJECT0_NPAGES; i++)
636 if (echo_object0_pages[i] != NULL) {
637 __free_pages (echo_object0_pages[i], 0);
638 echo_object0_pages[i] = NULL;
643 echo_object0_pages_init (void)
648 for (i = 0; i < ECHO_OBJECT0_NPAGES; i++) {
649 int gfp_mask = (i < ECHO_OBJECT0_NPAGES/2) ?
650 GFP_KERNEL : GFP_HIGHUSER;
652 pg = alloc_pages (gfp_mask, 0);
654 echo_object0_pages_fini ();
658 memset (kmap (pg), 0, PAGE_SIZE);
661 echo_object0_pages[i] = pg;
667 static int __init obdecho_init(void)
669 struct lprocfs_static_vars lvars;
672 printk(KERN_INFO "Lustre Echo OBD driver; info@clusterfs.com\n");
674 lprocfs_init_vars(&lvars);
676 xprocfs_init ("echo");
678 rc = echo_object0_pages_init ();
682 rc = class_register_type(&echo_obd_ops, lvars.module_vars,
683 OBD_ECHO_DEVICENAME);
687 rc = echo_client_init();
691 class_unregister_type(OBD_ECHO_DEVICENAME);
693 echo_object0_pages_fini ();
700 static void __exit obdecho_exit(void)
702 echo_client_cleanup();
703 class_unregister_type(OBD_ECHO_DEVICENAME);
704 echo_object0_pages_fini ();
708 MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
709 MODULE_DESCRIPTION("Lustre Testing Echo OBD driver");
710 MODULE_LICENSE("GPL");
712 module_init(obdecho_init);
713 module_exit(obdecho_exit);