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