lustre/portals/libcfs/module.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Copyright (C) 2001, 2002 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Portals, http://www.sf.net/projects/sandiaportals/
   7  *
   8  *   Portals is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2.1 of the GNU Lesser General
  10  *   Public License as published by the Free Software Foundation.
  11  *
  12  *   Portals is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public
  18  *   License along with Portals; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #ifndef EXPORT_SYMTAB
  23 # define EXPORT_SYMTAB
  24 #endif
  25 #define DEBUG_SUBSYSTEM S_PORTALS
  26
  27 #include <linux/config.h>
  28 #include <linux/module.h>
  29 #include <linux/kernel.h>
  30 #include <linux/mm.h>
  31 #include <linux/string.h>
  32 #include <linux/stat.h>
  33 #include <linux/init.h>
  34 #include <linux/errno.h>
  35 #include <linux/smp_lock.h>
  36 #include <linux/unistd.h>
  37
  38 #include <asm/system.h>
  39 #include <asm/uaccess.h>
  40
  41 #include <linux/fs.h>
  42 #include <linux/stat.h>
  43 #include <asm/uaccess.h>
  44 #include <asm/segment.h>
  45 #include <linux/miscdevice.h>
  46
  47 #include <portals/lib-p30.h>
  48 #include <portals/p30.h>
  49 #include <linux/kp30.h>
  50 #include <linux/portals_compat25.h>
  51
  52 #define PORTAL_MINOR 240
  53
  54 extern void (kping_client)(struct portal_ioctl_data *);
  55
  56 struct nal_cmd_handler {
  57         nal_cmd_handler_t nch_handler;
  58         void * nch_private;
  59 };
  60
  61 static struct nal_cmd_handler nal_cmd[NAL_MAX_NR + 1];
  62 struct semaphore nal_cmd_sem;
  63
  64 #ifdef PORTAL_DEBUG
  65 void
  66 kportal_assertion_failed (char *expr, char *file, char *func, int line)
  67 {
  68         portals_debug_msg(0, D_EMERG, file, func, line, CDEBUG_STACK(),
  69                           "ASSERTION(%s) failed\n", expr);
  70         LBUG_WITH_LOC(file, func, line);
  71 }
  72 #endif
  73
  74 void
  75 kportal_daemonize (char *str)
  76 {
  77 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,63))
  78         daemonize(str);
  79 #else
  80         daemonize();
  81         snprintf (current->comm, sizeof (current->comm), "%s", str);
  82 #endif
  83 }
  84
  85 void
  86 kportal_blockallsigs ()
  87 {
  88         unsigned long  flags;
  89
  90         SIGNAL_MASK_LOCK(current, flags);
  91         sigfillset(&current->blocked);
  92         RECALC_SIGPENDING;
  93         SIGNAL_MASK_UNLOCK(current, flags);
  94 }
  95
  96 /* called when opening /dev/device */
  97 static int kportal_psdev_open(struct inode * inode, struct file * file)
  98 {
  99         ENTRY;
 100
 101         if (!inode)
 102                 RETURN(-EINVAL);
 103         PORTAL_MODULE_USE;
 104         RETURN(0);
 105 }
 106
 107 /* called when closing /dev/device */
 108 static int kportal_psdev_release(struct inode * inode, struct file * file)
 109 {
 110         ENTRY;
 111
 112         if (!inode)
 113                 RETURN(-EINVAL);
 114
 115         PORTAL_MODULE_UNUSE;
 116         RETURN(0);
 117 }
 118
 119 static inline void freedata(void *data, int len)
 120 {
 121         PORTAL_FREE(data, len);
 122 }
 123
 124 static int
 125 kportal_add_route(int gateway_nalid, ptl_nid_t gateway_nid, ptl_nid_t lo_nid,
 126                   ptl_nid_t hi_nid)
 127 {
 128         int rc;
 129         kpr_control_interface_t *ci;
 130
 131         ci = (kpr_control_interface_t *) PORTAL_SYMBOL_GET (kpr_control_interface);
 132         if (ci == NULL)
 133                 return (-ENODEV);
 134
 135         rc = ci->kprci_add_route (gateway_nalid, gateway_nid, lo_nid, hi_nid);
 136
 137         PORTAL_SYMBOL_PUT(kpr_control_interface);
 138         return (rc);
 139 }
 140
 141 static int
 142 kportal_del_route(ptl_nid_t target)
 143 {
 144         int rc;
 145         kpr_control_interface_t *ci;
 146
 147         ci = (kpr_control_interface_t *)PORTAL_SYMBOL_GET(kpr_control_interface);
 148         if (ci == NULL)
 149                 return (-ENODEV);
 150
 151         rc = ci->kprci_del_route (target);
 152
 153         PORTAL_SYMBOL_PUT(kpr_control_interface);
 154         return (rc);
 155 }
 156
 157 static int
 158 kportal_get_route(int index, __u32 *gateway_nalidp, ptl_nid_t *gateway_nidp,
 159                   ptl_nid_t *lo_nidp, ptl_nid_t *hi_nidp)
 160 {
 161         int       gateway_nalid;
 162         ptl_nid_t gateway_nid;
 163         ptl_nid_t lo_nid;
 164         ptl_nid_t hi_nid;
 165         int       rc;
 166         kpr_control_interface_t *ci;
 167
 168         ci = (kpr_control_interface_t *) PORTAL_SYMBOL_GET(kpr_control_interface);
 169         if (ci == NULL)
 170                 return (-ENODEV);
 171
 172         rc = ci->kprci_get_route(index, &gateway_nalid, &gateway_nid, &lo_nid,
 173                                  &hi_nid);
 174
 175         if (rc == 0) {
 176                 CDEBUG(D_IOCTL, "got route [%d] %d "LPX64":"LPX64" - "LPX64"\n",
 177                        index, gateway_nalid, gateway_nid, lo_nid, hi_nid);
 178
 179                 *gateway_nalidp = (__u32)gateway_nalid;
 180                 *gateway_nidp   = (__u32)gateway_nid;
 181                 *lo_nidp        = (__u32)lo_nid;
 182                 *hi_nidp        = (__u32)hi_nid;
 183         }
 184
 185         PORTAL_SYMBOL_PUT (kpr_control_interface);
 186         return (rc);
 187 }
 188
 189 static int
 190 kportal_nal_cmd(int nal, struct portal_ioctl_data *data)
 191 {
 192         int rc = -EINVAL;
 193
 194         ENTRY;
 195
 196         down(&nal_cmd_sem);
 197         if (nal > 0 && nal <= NAL_MAX_NR && nal_cmd[nal].nch_handler) {
 198                 CDEBUG(D_IOCTL, "calling handler nal: %d, cmd: %d\n", nal, data->ioc_nal_cmd);
 199                 rc = nal_cmd[nal].nch_handler(data, nal_cmd[nal].nch_private);
 200         }
 201         up(&nal_cmd_sem);
 202         RETURN(rc);
 203 }
 204
 205 ptl_handle_ni_t *
 206 kportal_get_ni (int nal)
 207 {
 208
 209         switch (nal)
 210         {
 211         case QSWNAL:
 212                 return (PORTAL_SYMBOL_GET(kqswnal_ni));
 213         case SOCKNAL:
 214                 return (PORTAL_SYMBOL_GET(ksocknal_ni));
 215         case TOENAL:
 216                 return  (PORTAL_SYMBOL_GET(ktoenal_ni));
 217         case GMNAL:
 218                 return  (PORTAL_SYMBOL_GET(kgmnal_ni));
 219         case TCPNAL:
 220                 /* userspace NAL */
 221                 return (NULL);
 222         case SCIMACNAL:
 223                 return  (PORTAL_SYMBOL_GET(kscimacnal_ni));
 224         default:
 225                 /* A warning to a naive caller */
 226                 CERROR ("unknown nal: %d\n", nal);
 227                 return (NULL);
 228         }
 229 }
 230
 231 void
 232 kportal_put_ni (int nal)
 233 {
 234
 235         switch (nal)
 236         {
 237         case QSWNAL:
 238                 PORTAL_SYMBOL_PUT(kqswnal_ni);
 239                 break;
 240         case SOCKNAL:
 241                 PORTAL_SYMBOL_PUT(ksocknal_ni);
 242                 break;
 243         case TOENAL:
 244                 PORTAL_SYMBOL_PUT(ktoenal_ni);
 245                 break;
 246         case GMNAL:
 247                 PORTAL_SYMBOL_PUT(kgmnal_ni);
 248                 break;
 249         case TCPNAL:
 250                 /* A lesson to a malicious caller */
 251                 LBUG ();
 252         case SCIMACNAL:
 253                 PORTAL_SYMBOL_PUT(kscimacnal_ni);
 254                 break;
 255         default:
 256                 CERROR ("unknown nal: %d\n", nal);
 257         }
 258 }
 259
 260 int
 261 kportal_nal_register(int nal, nal_cmd_handler_t handler, void * private)
 262 {
 263         int rc = 0;
 264
 265         CDEBUG(D_IOCTL, "Register NAL %d, handler: %p\n", nal, handler);
 266
 267         if (nal > 0  && nal <= NAL_MAX_NR) {
 268                 down(&nal_cmd_sem);
 269                 if (nal_cmd[nal].nch_handler != NULL)
 270                         rc = -EBUSY;
 271                 else {
 272                         nal_cmd[nal].nch_handler = handler;
 273                         nal_cmd[nal].nch_private = private;
 274                 }
 275                 up(&nal_cmd_sem);
 276         }
 277         return rc;
 278 }
 279
 280 int
 281 kportal_nal_unregister(int nal)
 282 {
 283         int rc = 0;
 284
 285         CDEBUG(D_IOCTL, "Unregister NAL %d\n", nal);
 286
 287         if (nal > 0  && nal <= NAL_MAX_NR) {
 288                 down(&nal_cmd_sem);
 289                 nal_cmd[nal].nch_handler = NULL;
 290                 nal_cmd[nal].nch_private = NULL;
 291                 up(&nal_cmd_sem);
 292         }
 293         return rc;
 294 }
 295
 296
 297 static int kportal_ioctl(struct inode *inode, struct file *file,
 298                          unsigned int cmd, unsigned long arg)
 299 {
 300         int err = 0;
 301         char buf[1024];
 302         struct portal_ioctl_data *data;
 303
 304         ENTRY;
 305
 306         if ( _IOC_TYPE(cmd) != IOC_PORTAL_TYPE ||
 307              _IOC_NR(cmd) < IOC_PORTAL_MIN_NR  ||
 308              _IOC_NR(cmd) > IOC_PORTAL_MAX_NR ) {
 309                 CDEBUG(D_IOCTL, "invalid ioctl ( type %d, nr %d, size %d )\n",
 310                                 _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd));
 311                 RETURN(-EINVAL);
 312         }
 313
 314         if (portal_ioctl_getdata(buf, buf + 800, (void *)arg)) {
 315                 CERROR("PORTALS ioctl: data error\n");
 316                 RETURN(-EINVAL);
 317         }
 318
 319         data = (struct portal_ioctl_data *)buf;
 320
 321         switch (cmd) {
 322         case IOC_PORTAL_SET_DAEMON:
 323                 RETURN (portals_debug_set_daemon (
 324                                         (unsigned int) data->ioc_count,
 325                                         (unsigned int) data->ioc_inllen1,
 326                                         (char *) data->ioc_inlbuf1,
 327                                         (unsigned int) data->ioc_misc));
 328         case IOC_PORTAL_GET_DEBUG: {
 329                 __s32 size = portals_debug_copy_to_user(data->ioc_pbuf1,
 330                                                         data->ioc_plen1);
 331
 332                 if (size < 0)
 333                         RETURN(size);
 334
 335                 data->ioc_size = size;
 336                 err = copy_to_user((char *)arg, data, sizeof(*data));
 337                 RETURN(err);
 338         }
 339         case IOC_PORTAL_CLEAR_DEBUG:
 340                 portals_debug_clear_buffer();
 341                 RETURN(0);
 342         case IOC_PORTAL_PANIC:
 343                 if (!capable (CAP_SYS_BOOT))
 344                         RETURN (-EPERM);
 345                 panic("debugctl-invoked panic");
 346                 RETURN(0);
 347         case IOC_PORTAL_MARK_DEBUG:
 348                 if (data->ioc_inlbuf1 == NULL ||
 349                     data->ioc_inlbuf1[data->ioc_inllen1 - 1] != '\0')
 350                         RETURN(-EINVAL);
 351                 portals_debug_mark_buffer(data->ioc_inlbuf1);
 352                 RETURN(0);
 353         case IOC_PORTAL_PING: {
 354                 void (*ping)(struct portal_ioctl_data *);
 355
 356                 CDEBUG(D_IOCTL, "doing %d pings to nid "LPU64"\n",
 357                        data->ioc_count, data->ioc_nid);
 358                 ping = PORTAL_SYMBOL_GET(kping_client);
 359                 if (!ping)
 360                         CERROR("PORTAL_SYMBOL_GET failed\n");
 361                 else {
 362                         ping(data);
 363                         PORTAL_SYMBOL_PUT(kping_client);
 364                 }
 365                 RETURN(0);
 366         }
 367
 368         case IOC_PORTAL_ADD_ROUTE:
 369                 CDEBUG(D_IOCTL, "Adding route: [%d] "LPU64" : "LPU64" - "LPU64"\n",
 370                        data->ioc_nal, data->ioc_nid, data->ioc_nid2,
 371                        data->ioc_nid3);
 372                 err = kportal_add_route(data->ioc_nal, data->ioc_nid,
 373                                         MIN (data->ioc_nid2, data->ioc_nid3),
 374                                         MAX (data->ioc_nid2, data->ioc_nid3));
 375                 break;
 376
 377         case IOC_PORTAL_DEL_ROUTE:
 378                 CDEBUG (D_IOCTL, "Removing route to "LPU64"\n", data->ioc_nid);
 379                 err = kportal_del_route (data->ioc_nid);
 380                 break;
 381
 382         case IOC_PORTAL_GET_ROUTE:
 383                 CDEBUG (D_IOCTL, "Getting route [%d]\n", data->ioc_count);
 384                 err = kportal_get_route(data->ioc_count, &data->ioc_nal,
 385                                         &data->ioc_nid, &data->ioc_nid2,
 386                                         &data->ioc_nid3);
 387                 if (err == 0)
 388                         if (copy_to_user((char *)arg, data, sizeof (*data)))
 389                                 err = -EFAULT;
 390                 break;
 391
 392         case IOC_PORTAL_GET_NID: {
 393                 const ptl_handle_ni_t *nip;
 394                 ptl_process_id_t       pid;
 395
 396                 CDEBUG (D_IOCTL, "Getting nid [%d]\n", data->ioc_nal);
 397
 398                 nip = kportal_get_ni (data->ioc_nal);
 399                 if (nip == NULL)
 400                         RETURN (-EINVAL);
 401
 402                 err = PtlGetId (*nip, &pid);
 403                 LASSERT (err == PTL_OK);
 404                 kportal_put_ni (data->ioc_nal);
 405
 406                 data->ioc_nid = pid.nid;
 407                 if (copy_to_user ((char *)arg, data, sizeof (*data)))
 408                         err = -EFAULT;
 409                 break;
 410         }
 411
 412         case IOC_PORTAL_NAL_CMD:
 413                 CDEBUG (D_IOCTL, "nal command nal %d cmd %d\n", data->ioc_nal,
 414                         data->ioc_nal_cmd);
 415                 err = kportal_nal_cmd(data->ioc_nal, data);
 416                 if (err == 0)
 417                         if (copy_to_user((char *)arg, data, sizeof (*data)))
 418                                 err = -EFAULT;
 419                 break;
 420
 421         case IOC_PORTAL_FAIL_NID: {
 422                 const ptl_handle_ni_t *nip;
 423
 424                 CDEBUG (D_IOCTL, "fail nid: [%d] "LPU64" count %d\n",
 425                         data->ioc_nal, data->ioc_nid, data->ioc_count);
 426
 427                 nip = kportal_get_ni (data->ioc_nal);
 428                 if (nip == NULL)
 429                         return (-EINVAL);
 430
 431                 err = PtlFailNid (*nip, data->ioc_nid, data->ioc_count);
 432                 break;
 433         }
 434
 435         default:
 436                 err = -EINVAL;
 437                 break;
 438         }
 439
 440         RETURN(err);
 441 }
 442
 443
 444 static struct file_operations portalsdev_fops = {
 445         ioctl:   kportal_ioctl,
 446         open:    kportal_psdev_open,
 447         release: kportal_psdev_release
 448 };
 449
 450
 451 static struct miscdevice portal_dev = {
 452         PORTAL_MINOR,
 453         "portals",
 454         &portalsdev_fops
 455 };
 456
 457 extern int insert_proc(void);
 458 extern void remove_proc(void);
 459 MODULE_AUTHOR("Peter J. Braam <braam@clusterfs.com>");
 460 MODULE_DESCRIPTION("Portals v3.1");
 461 MODULE_LICENSE("GPL");
 462
 463 static int init_kportals_module(void)
 464 {
 465         int rc;
 466
 467         rc = portals_debug_init(5 * 1024 * 1024);
 468         if (rc < 0) {
 469                 printk(KERN_ERR "portals_debug_init: %d\n", rc);
 470                 return (rc);
 471         }
 472
 473         sema_init(&nal_cmd_sem, 1);
 474
 475         rc = misc_register(&portal_dev);
 476         if (rc) {
 477                 CERROR("misc_register: error %d\n", rc);
 478                 goto cleanup_debug;
 479         }
 480
 481         rc = PtlInit();
 482         if (rc) {
 483                 CERROR("PtlInit: error %d\n", rc);
 484                 goto cleanup_deregister;
 485         }
 486
 487         rc = insert_proc();
 488         if (rc) {
 489                 CERROR("insert_proc: error %d\n", rc);
 490                 goto cleanup_fini;
 491         }
 492
 493         CDEBUG (D_OTHER, "portals setup OK\n");
 494         return (0);
 495
 496  cleanup_fini:
 497         PtlFini();
 498  cleanup_deregister:
 499         misc_deregister(&portal_dev);
 500  cleanup_debug:
 501         portals_debug_cleanup();
 502         return rc;
 503 }
 504
 505 static void exit_kportals_module(void)
 506 {
 507         int rc;
 508
 509         remove_proc();
 510         PtlFini();
 511
 512         CDEBUG(D_MALLOC, "before Portals cleanup: kmem %d\n",
 513                atomic_read(&portal_kmemory));
 514
 515
 516         rc = misc_deregister(&portal_dev);
 517         if (rc)
 518                 CERROR("misc_deregister error %d\n", rc);
 519
 520         if (atomic_read(&portal_kmemory) != 0)
 521                 CERROR("Portals memory leaked: %d bytes\n",
 522                        atomic_read(&portal_kmemory));
 523
 524         rc = portals_debug_cleanup();
 525         if (rc)
 526                 printk(KERN_ERR "portals_debug_cleanup: %d\n", rc);
 527 }
 528
 529 EXPORT_SYMBOL(lib_dispatch);
 530 EXPORT_SYMBOL(PtlMEAttach);
 531 EXPORT_SYMBOL(PtlMEInsert);
 532 EXPORT_SYMBOL(PtlMEUnlink);
 533 EXPORT_SYMBOL(PtlEQAlloc);
 534 EXPORT_SYMBOL(PtlMDAttach);
 535 EXPORT_SYMBOL(PtlMDUnlink);
 536 EXPORT_SYMBOL(PtlNIInit);
 537 EXPORT_SYMBOL(PtlNIFini);
 538 EXPORT_SYMBOL(PtlNIDebug);
 539 EXPORT_SYMBOL(PtlInit);
 540 EXPORT_SYMBOL(PtlFini);
 541 EXPORT_SYMBOL(PtlPut);
 542 EXPORT_SYMBOL(PtlGet);
 543 EXPORT_SYMBOL(ptl_err_str);
 544 EXPORT_SYMBOL(portal_subsystem_debug);
 545 EXPORT_SYMBOL(portal_debug);
 546 EXPORT_SYMBOL(portal_stack);
 547 EXPORT_SYMBOL(portal_printk);
 548 EXPORT_SYMBOL(PtlEQWait);
 549 EXPORT_SYMBOL(PtlEQFree);
 550 EXPORT_SYMBOL(PtlEQGet);
 551 EXPORT_SYMBOL(PtlGetId);
 552 EXPORT_SYMBOL(PtlMDBind);
 553 EXPORT_SYMBOL(lib_iov_nob);
 554 EXPORT_SYMBOL(lib_copy_iov2buf);
 555 EXPORT_SYMBOL(lib_copy_buf2iov);
 556 EXPORT_SYMBOL(lib_kiov_nob);
 557 EXPORT_SYMBOL(lib_copy_kiov2buf);
 558 EXPORT_SYMBOL(lib_copy_buf2kiov);
 559 EXPORT_SYMBOL(lib_finalize);
 560 EXPORT_SYMBOL(lib_parse);
 561 EXPORT_SYMBOL(lib_init);
 562 EXPORT_SYMBOL(lib_fini);
 563 EXPORT_SYMBOL(portal_kmemory);
 564 EXPORT_SYMBOL(kportal_daemonize);
 565 EXPORT_SYMBOL(kportal_blockallsigs);
 566 EXPORT_SYMBOL(kportal_nal_register);
 567 EXPORT_SYMBOL(kportal_nal_unregister);
 568 EXPORT_SYMBOL(kportal_assertion_failed);
 569 EXPORT_SYMBOL(dispatch_name);
 570 EXPORT_SYMBOL(kportal_get_ni);
 571 EXPORT_SYMBOL(kportal_put_ni);
 572
 573 module_init(init_kportals_module);
 574 module_exit (exit_kportals_module);