lustre/obdecho/echo.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  linux/fs/ext2_obd/ext2_obd.c
   5  *
   6  * Copyright (C) 2001  Cluster File Systems, Inc.
   7  *
   8  * This code is issued under the GNU General Public License.
   9  * See the file COPYING in this distribution
  10  *
  11  * by Peter Braam <braam@clusterfs.com>
  12  */
  13
  14 static char rcsid[] __attribute ((unused)) = "$Id: echo.c,v 1.24 2002/08/19 23:45:00 adilger Exp $";
  15 #define OBDECHO_VERSION "$Revision: 1.24 $"
  16
  17 #define EXPORT_SYMTAB
  18
  19 #include <linux/version.h>
  20 #include <linux/module.h>
  21 #include <linux/fs.h>
  22 #include <linux/stat.h>
  23 #include <linux/locks.h>
  24 #include <linux/ext2_fs.h>
  25 #include <linux/quotaops.h>
  26 #include <linux/proc_fs.h>
  27 #include <linux/init.h>
  28 #include <asm/unistd.h>
  29
  30 #define DEBUG_SUBSYSTEM S_ECHO
  31
  32 #include <linux/obd_support.h>
  33 #include <linux/obd_class.h>
  34 #include <linux/obd_echo.h>
  35 #include <linux/lustre_debug.h>
  36 #include <linux/lustre_dlm.h>
  37
  38 extern struct obd_device obd_dev[MAX_OBD_DEVICES];
  39 static struct obdo OA;
  40 static obd_count GEN;
  41 static long echo_pages = 0;
  42
  43 static atomic_t echo_page_rws;
  44 static atomic_t echo_getattrs;
  45
  46 #define ECHO_PROC_STAT "sys/obdecho"
  47
  48 int
  49 echo_proc_read (char *page, char **start, off_t off, int count, int *eof, void *data)
  50 {
  51         int                len;
  52         int                attrs = atomic_read (&echo_getattrs);
  53         int                pages = atomic_read (&echo_page_rws);
  54
  55         *eof = 1;
  56         if (off != 0)
  57                 return (0);
  58
  59         len = sprintf (page, "%d %d\n", pages, attrs);
  60
  61         *start = page;
  62         return (len);
  63 }
  64
  65 int
  66 echo_proc_write (struct file *file, const char *ubuffer, unsigned long count, void *data)
  67 {
  68         /* Ignore what we've been asked to write, and just zero the stats counters */
  69         atomic_set (&echo_page_rws, 0);
  70         atomic_set (&echo_getattrs, 0);
  71
  72         return (count);
  73 }
  74
  75 void
  76 echo_proc_init(void)
  77 {
  78         struct proc_dir_entry *entry;
  79
  80         entry = create_proc_entry(ECHO_PROC_STAT, S_IFREG|S_IRUGO|S_IWUSR,NULL);
  81
  82         if (entry == NULL) {
  83                 CERROR("couldn't create proc entry %s\n", ECHO_PROC_STAT);
  84                 return;
  85         }
  86
  87         entry->data = NULL;
  88         entry->read_proc = echo_proc_read;
  89         entry->write_proc = echo_proc_write;
  90 }
  91
  92 void echo_proc_fini(void)
  93 {
  94         remove_proc_entry(ECHO_PROC_STAT, 0);
  95 }
  96
  97 static int echo_connect(struct lustre_handle *conn, struct obd_device *obd,
  98                         char *cluuid)
  99 {
 100         int rc;
 101
 102         MOD_INC_USE_COUNT;
 103         rc = class_connect(conn, obd, NULL);
 104
 105         if (rc)
 106                 MOD_DEC_USE_COUNT;
 107
 108         return rc;
 109 }
 110
 111 static int echo_disconnect(struct lustre_handle *conn)
 112 {
 113         int rc;
 114
 115         rc = class_disconnect(conn);
 116         if (!rc)
 117                 MOD_DEC_USE_COUNT;
 118
 119         return rc;
 120 }
 121
 122 static int echo_getattr(struct lustre_handle *conn, struct obdo *oa,
 123                         struct lov_stripe_md *md)
 124 {
 125         memcpy(oa, &OA, sizeof(*oa));
 126         oa->o_mode = ++GEN;
 127
 128         atomic_inc (&echo_getattrs);
 129
 130         return 0;
 131 }
 132
 133 #define DESC_PRIV 0x10293847
 134
 135 int echo_preprw(int cmd, struct lustre_handle *conn, int objcount,
 136                 struct obd_ioobj *obj, int niocount, struct niobuf_remote *nb,
 137                 struct niobuf_local *res, void **desc_private)
 138 {
 139         struct niobuf_local *r = res;
 140         int rc = 0;
 141         int i;
 142
 143         ENTRY;
 144
 145         memset(res, 0, sizeof(*res) * niocount);
 146
 147         CDEBUG(D_PAGE, "%s %d obdos with %d IOs\n",
 148                cmd == OBD_BRW_READ ? "reading" : "writing", objcount, niocount);
 149
 150         *desc_private = (void *)DESC_PRIV;
 151
 152         for (i = 0; i < objcount; i++, obj++) {
 153                 int j;
 154
 155                 for (j = 0 ; j < obj->ioo_bufcnt ; j++, nb++, r++) {
 156                         r->page = alloc_pages(GFP_KERNEL, 0);
 157                         if (!r->page) {
 158                                 CERROR("can't get page %d/%d for id "LPU64"\n",
 159                                        j, obj->ioo_bufcnt, obj->ioo_id);
 160                                 GOTO(preprw_cleanup, rc = -ENOMEM);
 161                         }
 162                         echo_pages++;
 163
 164                         r->offset = nb->offset;
 165                         r->addr = kmap(r->page);
 166                         r->len = nb->len;
 167
 168                         CDEBUG(D_PAGE, "$$$$ get page %p, addr %p@"LPU64"\n",
 169                                r->page, r->addr, r->offset);
 170                         if (cmd & OBD_BRW_READ)
 171                                 page_debug_setup(r->addr, r->len, r->offset,
 172                                                  obj->ioo_id);
 173                 }
 174         }
 175         CDEBUG(D_PAGE, "%ld pages allocated after prep\n", echo_pages);
 176
 177         RETURN(0);
 178
 179 preprw_cleanup:
 180         /* It is possible that we would rather handle errors by  allow
 181          * any already-set-up pages to complete, rather than tearing them
 182          * all down again.  I believe that this is what the in-kernel
 183          * prep/commit operations do.
 184          */
 185         CERROR("cleaning up %ld pages (%d obdos)\n", (long)(r - res), objcount);
 186         while (r-- > res) {
 187                 kunmap(r->page);
 188                 __free_pages(r->page, 0);
 189                 echo_pages--;
 190         }
 191         memset(res, 0, sizeof(*res) * niocount);
 192
 193         return rc;
 194 }
 195
 196 int echo_commitrw(int cmd, struct lustre_handle *conn, int objcount,
 197                   struct obd_ioobj *obj, int niocount, struct niobuf_local *res,
 198                   void *desc_private)
 199 {
 200         struct niobuf_local *r = res;
 201         int rc = 0;
 202         int i;
 203         ENTRY;
 204
 205         CDEBUG(D_PAGE, "%s %d obdos with %d IOs\n",
 206                cmd == OBD_BRW_READ ? "reading" : "writing", objcount, niocount);
 207
 208         if (niocount && !r) {
 209                 CERROR("NULL res niobuf with niocount %d\n", niocount);
 210                 RETURN(-EINVAL);
 211         }
 212
 213         LASSERT(desc_private == (void *)DESC_PRIV);
 214
 215         for (i = 0; i < objcount; i++, obj++) {
 216                 int j;
 217
 218                 for (j = 0 ; j < obj->ioo_bufcnt ; j++, r++) {
 219                         struct page *page = r->page;
 220                         void *addr;
 221
 222                         if (!page || !(addr = page_address(page)) ||
 223                             !kern_addr_valid(addr)) {
 224
 225                                 CERROR("bad page "LPU64":%p, buf %d/%d\n",
 226                                        obj->ioo_id, page, j, obj->ioo_bufcnt);
 227                                 GOTO(commitrw_cleanup, rc = -EFAULT);
 228                         }
 229
 230                         atomic_inc (&echo_page_rws);
 231
 232                         CDEBUG(D_PAGE, "$$$$ use page %p, addr %p@"LPU64"\n",
 233                                r->page, addr, r->offset);
 234                         if (cmd & OBD_BRW_WRITE)
 235                                 page_debug_check("echo", addr, r->len,
 236                                                  r->offset, obj->ioo_id);
 237
 238                         kunmap(page);
 239                         __free_pages(page, 0);
 240                         echo_pages--;
 241                 }
 242         }
 243         CDEBUG(D_PAGE, "%ld pages remain after commit\n", echo_pages);
 244         RETURN(0);
 245
 246 commitrw_cleanup:
 247         CERROR("cleaning up %ld pages (%d obdos)\n",
 248                niocount - (long)(r - res) - 1, objcount);
 249         while (++r < res + niocount) {
 250                 struct page *page = r->page;
 251
 252                 kunmap(page);
 253                 __free_pages(page, 0);
 254                 echo_pages--;
 255         }
 256         return rc;
 257 }
 258
 259 static int echo_setup(struct obd_device *obddev, obd_count len, void *buf)
 260 {
 261         ENTRY;
 262
 263         obddev->obd_namespace =
 264                 ldlm_namespace_new("echo-tgt", LDLM_NAMESPACE_SERVER);
 265         if (obddev->obd_namespace == NULL) {
 266                 LBUG();
 267                 RETURN(-ENOMEM);
 268         }
 269
 270         RETURN(0);
 271 }
 272
 273 static int echo_cleanup(struct obd_device *obddev)
 274 {
 275         ENTRY;
 276
 277         ldlm_namespace_free(obddev->obd_namespace);
 278
 279         RETURN(0);
 280 }
 281
 282 struct obd_ops echo_obd_ops = {
 283         o_connect:     echo_connect,
 284         o_disconnect:  echo_disconnect,
 285         o_getattr:     echo_getattr,
 286         o_preprw:      echo_preprw,
 287         o_commitrw:    echo_commitrw,
 288         o_setup:       echo_setup,
 289         o_cleanup:     echo_cleanup
 290 };
 291
 292 static int __init obdecho_init(void)
 293 {
 294         printk(KERN_INFO "Echo OBD driver " OBDECHO_VERSION " info@clusterfs.com\n");
 295
 296         echo_proc_init();
 297
 298         return class_register_type(&echo_obd_ops, OBD_ECHO_DEVICENAME);
 299 }
 300
 301 static void __exit obdecho_exit(void)
 302 {
 303         echo_proc_fini ();
 304
 305         CERROR("%ld prep/commitrw pages leaked\n", echo_pages);
 306         class_unregister_type(OBD_ECHO_DEVICENAME);
 307 }
 308
 309 MODULE_AUTHOR("Cluster Filesystems Inc. <info@clusterfs.com>");
 310 MODULE_DESCRIPTION("Lustre Testing Echo OBD driver " OBDECHO_VERSION);
 311 MODULE_LICENSE("GPL");
 312
 313 module_init(obdecho_init);
 314 module_exit(obdecho_exit);