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.26 2002/08/22 13:34:20 eeb Exp $";
  15 #define OBDECHO_VERSION "$Revision: 1.26 $"
  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 highmem = (obj->ioo_id & 1) != 0;
 154                 int verify  = obj->ioo_id != 0;
 155                 int j;
 156
 157                 for (j = 0 ; j < obj->ioo_bufcnt ; j++, nb++, r++) {
 158                         r->page = alloc_pages(highmem ? GFP_HIGHUSER : GFP_KERNEL, 0);
 159                         if (!r->page) {
 160                                 CERROR("can't get page %d/%d for id "LPU64"\n",
 161                                        j, obj->ioo_bufcnt, obj->ioo_id);
 162                                 GOTO(preprw_cleanup, rc = -ENOMEM);
 163                         }
 164                         echo_pages++;
 165
 166                         r->offset = nb->offset;
 167                         r->addr = kmap(r->page);
 168                         r->len = nb->len;
 169
 170                         CDEBUG(D_PAGE, "$$$$ get page %p, addr %p@"LPU64"\n",
 171                                r->page, r->addr, r->offset);
 172
 173                         if (verify && (cmd & OBD_BRW_READ) != 0)
 174                                 page_debug_setup(r->addr, r->len, r->offset,
 175                                                  obj->ioo_id);
 176                 }
 177         }
 178         CDEBUG(D_PAGE, "%ld pages allocated after prep\n", echo_pages);
 179
 180         RETURN(0);
 181
 182 preprw_cleanup:
 183         /* It is possible that we would rather handle errors by  allow
 184          * any already-set-up pages to complete, rather than tearing them
 185          * all down again.  I believe that this is what the in-kernel
 186          * prep/commit operations do.
 187          */
 188         CERROR("cleaning up %ld pages (%d obdos)\n", (long)(r - res), objcount);
 189         while (r-- > res) {
 190                 kunmap(r->page);
 191                 __free_pages(r->page, 0);
 192                 echo_pages--;
 193         }
 194         memset(res, 0, sizeof(*res) * niocount);
 195
 196         return rc;
 197 }
 198
 199 int echo_commitrw(int cmd, struct lustre_handle *conn, int objcount,
 200                   struct obd_ioobj *obj, int niocount, struct niobuf_local *res,
 201                   void *desc_private)
 202 {
 203         struct niobuf_local *r = res;
 204         int rc = 0;
 205         int i;
 206         ENTRY;
 207
 208         CDEBUG(D_PAGE, "%s %d obdos with %d IOs\n",
 209                cmd == OBD_BRW_READ ? "reading" : "writing", objcount, niocount);
 210
 211         if (niocount && !r) {
 212                 CERROR("NULL res niobuf with niocount %d\n", niocount);
 213                 RETURN(-EINVAL);
 214         }
 215
 216         LASSERT(desc_private == (void *)DESC_PRIV);
 217
 218         for (i = 0; i < objcount; i++, obj++) {
 219                 int verify = obj->ioo_id != 0;
 220                 int j;
 221
 222                 for (j = 0 ; j < obj->ioo_bufcnt ; j++, r++) {
 223                         struct page *page = r->page;
 224                         void *addr;
 225
 226                         if (!page || !(addr = page_address(page)) ||
 227                             !kern_addr_valid(addr)) {
 228
 229                                 CERROR("bad page "LPU64":%p, buf %d/%d\n",
 230                                        obj->ioo_id, page, j, obj->ioo_bufcnt);
 231                                 GOTO(commitrw_cleanup, rc = -EFAULT);
 232                         }
 233
 234                         atomic_inc (&echo_page_rws);
 235
 236                         CDEBUG(D_PAGE, "$$$$ use page %p, addr %p@"LPU64"\n",
 237                                r->page, addr, r->offset);
 238
 239                         if (verify && (cmd & OBD_BRW_WRITE))
 240                                 page_debug_check("echo", addr, r->len,
 241                                                  r->offset, obj->ioo_id);
 242
 243                         kunmap(page);
 244                         __free_pages(page, 0);
 245                         echo_pages--;
 246                 }
 247         }
 248         CDEBUG(D_PAGE, "%ld pages remain after commit\n", echo_pages);
 249         RETURN(0);
 250
 251 commitrw_cleanup:
 252         CERROR("cleaning up %ld pages (%d obdos)\n",
 253                niocount - (long)(r - res) - 1, objcount);
 254         while (++r < res + niocount) {
 255                 struct page *page = r->page;
 256
 257                 kunmap(page);
 258                 __free_pages(page, 0);
 259                 echo_pages--;
 260         }
 261         return rc;
 262 }
 263
 264 static int echo_setup(struct obd_device *obddev, obd_count len, void *buf)
 265 {
 266         ENTRY;
 267
 268         obddev->obd_namespace =
 269                 ldlm_namespace_new("echo-tgt", LDLM_NAMESPACE_SERVER);
 270         if (obddev->obd_namespace == NULL) {
 271                 LBUG();
 272                 RETURN(-ENOMEM);
 273         }
 274
 275         RETURN(0);
 276 }
 277
 278 static int echo_cleanup(struct obd_device *obddev)
 279 {
 280         ENTRY;
 281
 282         ldlm_namespace_free(obddev->obd_namespace);
 283
 284         RETURN(0);
 285 }
 286
 287 struct obd_ops echo_obd_ops = {
 288         o_connect:     echo_connect,
 289         o_disconnect:  echo_disconnect,
 290         o_getattr:     echo_getattr,
 291         o_preprw:      echo_preprw,
 292         o_commitrw:    echo_commitrw,
 293         o_setup:       echo_setup,
 294         o_cleanup:     echo_cleanup
 295 };
 296
 297 static int __init obdecho_init(void)
 298 {
 299         printk(KERN_INFO "Echo OBD driver " OBDECHO_VERSION " info@clusterfs.com\n");
 300
 301         echo_proc_init();
 302
 303         return class_register_type(&echo_obd_ops, OBD_ECHO_DEVICENAME);
 304 }
 305
 306 static void __exit obdecho_exit(void)
 307 {
 308         echo_proc_fini ();
 309
 310         CERROR("%ld prep/commitrw pages leaked\n", echo_pages);
 311         class_unregister_type(OBD_ECHO_DEVICENAME);
 312 }
 313
 314 MODULE_AUTHOR("Cluster Filesystems Inc. <info@clusterfs.com>");
 315 MODULE_DESCRIPTION("Lustre Testing Echo OBD driver " OBDECHO_VERSION);
 316 MODULE_LICENSE("GPL");
 317
 318 module_init(obdecho_init);
 319 module_exit(obdecho_exit);