krping_dev.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*
    2  * This code lifted from:
    3  *      Simple `echo' pseudo-device KLD
    4  *      Murray Stokely
    5  *      Converted to 5.X by Søren (Xride) Straarup
    6  */
    7 
    8 /*
    9  * /bin/echo "server,port=9999,addr=192.168.69.142,validate" > /dev/krping
   10  * /bin/echo "client,port=9999,addr=192.168.69.142,validate" > /dev/krping
   11  */
   12 
   13 #include <sys/cdefs.h>
   14 __FBSDID("$FreeBSD$");
   15 
   16 #include <sys/types.h>
   17 #include <sys/param.h>  /* defines used in kernel.h and module.h */
   18 #include <sys/module.h>
   19 #include <sys/systm.h>  /* uprintf */
   20 #include <sys/errno.h>
   21 #include <sys/kernel.h> /* types used in module initialization */
   22 #include <sys/conf.h>   /* cdevsw struct */
   23 #include <sys/uio.h>    /* uio struct */
   24 #include <sys/malloc.h>
   25 #include <sys/proc.h>
   26 #include <sys/sysctl.h>
   27 #include <machine/stdarg.h>
   28 
   29 #include "krping.h"
   30 
   31 #define BUFFERSIZE 512
   32 
   33 SYSCTL_NODE(_dev, OID_AUTO, krping, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
   34     "kernel rping module");
   35 
   36 int krping_debug = 0;
   37 SYSCTL_INT(_dev_krping, OID_AUTO, debug, CTLFLAG_RW, &krping_debug, 0 , "");
   38 
   39 /* Function prototypes */
   40 static d_open_t      krping_open;
   41 static d_close_t     krping_close;
   42 static d_read_t      krping_read;
   43 static d_write_t     krping_write;
   44 static d_purge_t     krping_purge;
   45 
   46 /* Character device entry points */
   47 static struct cdevsw krping_cdevsw = {
   48         .d_version = D_VERSION,
   49         .d_open = krping_open,
   50         .d_close = krping_close,
   51         .d_read = krping_read,
   52         .d_write = krping_write,
   53         .d_purge = krping_purge,
   54         .d_name = "krping",
   55 };
   56 
   57 typedef struct s_krping {
   58         char msg[BUFFERSIZE];
   59         int len;
   60 } krping_t;
   61 
   62 struct stats_list_entry {
   63         STAILQ_ENTRY(stats_list_entry) link;
   64         struct krping_stats *stats;
   65 };
   66 STAILQ_HEAD(stats_list, stats_list_entry);
   67 
   68 /* vars */
   69 static struct cdev *krping_dev;
   70 
   71 static int
   72 krping_loader(struct module *m, int what, void *arg)
   73 {
   74         int err = 0;
   75 
   76         switch (what) {
   77         case MOD_LOAD:                /* kldload */
   78                 krping_dev = make_dev(&krping_cdevsw, 0, UID_ROOT, GID_WHEEL,
   79                                         0600, "krping");
   80                 printf("Krping device loaded.\n");
   81                 break;
   82         case MOD_UNLOAD:
   83                 destroy_dev(krping_dev);
   84                 printf("Krping device unloaded.\n");
   85                 break;
   86         default:
   87                 err = EOPNOTSUPP;
   88                 break;
   89         }
   90 
   91         return (err);
   92 }
   93 
   94 static int
   95 krping_open(struct cdev *dev, int oflags, int devtype, struct thread *p)
   96 {
   97 
   98         return (0);
   99 }
  100 
  101 static int
  102 krping_close(struct cdev *dev, int fflag, int devtype, struct thread *p)
  103 {
  104 
  105         return 0;
  106 }
  107 
  108 static void
  109 krping_copy_stats(struct krping_stats *stats, void *arg)
  110 {
  111         struct stats_list_entry *s;
  112         struct stats_list *list = arg;
  113 
  114         s = malloc(sizeof(*s), M_DEVBUF, M_NOWAIT | M_ZERO);
  115         if (s == NULL)
  116                 return;
  117         if (stats != NULL) {
  118                 s->stats = malloc(sizeof(*stats), M_DEVBUF, M_NOWAIT | M_ZERO);
  119                 if (s->stats == NULL) {
  120                         free(s, M_DEVBUF);
  121                         return;
  122                 }
  123                 *s->stats = *stats;
  124         }
  125         STAILQ_INSERT_TAIL(list, s, link);
  126 }
  127 
  128 static int
  129 krping_read(struct cdev *dev, struct uio *uio, int ioflag)
  130 {
  131         int num = 1;
  132         struct stats_list list;
  133         struct stats_list_entry *e;
  134 
  135         STAILQ_INIT(&list);
  136         krping_walk_cb_list(krping_copy_stats, &list);
  137 
  138         if (STAILQ_EMPTY(&list))
  139                 return (0);
  140 
  141         uprintf("krping: %4s %10s %10s %10s %10s %10s %10s %10s %10s %10s\n",
  142             "num", "device", "snd bytes", "snd msgs", "rcv bytes", "rcv msgs",
  143             "wr bytes", "wr msgs", "rd bytes", "rd msgs");
  144 
  145         while (!STAILQ_EMPTY(&list)) {
  146                 e = STAILQ_FIRST(&list);
  147                 STAILQ_REMOVE_HEAD(&list, link);
  148                 if (e->stats == NULL)
  149                         uprintf("krping: %d listen\n", num);
  150                 else {
  151                         struct krping_stats *stats = e->stats;
  152 
  153                         uprintf("krping: %4d %10s %10llu %10llu %10llu %10llu "
  154                             "%10llu %10llu %10llu %10llu\n", num, stats->name,
  155                             stats->send_bytes, stats->send_msgs,
  156                             stats->recv_bytes, stats->recv_msgs,
  157                             stats->write_bytes, stats->write_msgs,
  158                             stats->read_bytes, stats->read_msgs);
  159                         free(stats, M_DEVBUF);
  160                 }
  161                 num++;
  162                 free(e, M_DEVBUF);
  163         }
  164 
  165         return (0);
  166 }
  167 
  168 static int
  169 krping_write(struct cdev *dev, struct uio *uio, int ioflag)
  170 {
  171         int err = 0;
  172         int amt;
  173         int remain = BUFFERSIZE;
  174         char *cp;
  175         krping_t *krpingmsg;
  176 
  177         krpingmsg = malloc(sizeof *krpingmsg, M_DEVBUF, M_WAITOK|M_ZERO);
  178         if (!krpingmsg) {
  179                 uprintf("Could not malloc mem!\n");
  180                 return ENOMEM;
  181         }
  182 
  183         cp = krpingmsg->msg;
  184         while (uio->uio_resid) {
  185                 amt = MIN(uio->uio_resid, remain);
  186                 if (amt == 0)
  187                         break;
  188 
  189                 /* Copy the string in from user memory to kernel memory */
  190                 err = uiomove(cp, amt, uio);
  191                 if (err) {
  192                         uprintf("Write failed: bad address!\n");
  193                         goto done;
  194                 }
  195                 cp += amt;
  196                 remain -= amt;
  197         }
  198 
  199         if (uio->uio_resid != 0) {
  200                 uprintf("Message too big. max size is %d!\n", BUFFERSIZE);
  201                 err = EMSGSIZE;
  202                 goto done;
  203         }
  204 
  205         /* null terminate and remove the \n */
  206         cp--;
  207         *cp = 0;
  208         krpingmsg->len = (unsigned long)(cp - krpingmsg->msg);
  209         uprintf("krping: write string = |%s|\n", krpingmsg->msg);
  210         err = krping_doit(krpingmsg->msg);
  211 done:
  212         free(krpingmsg, M_DEVBUF);
  213         return(err);
  214 }
  215 
  216 static void
  217 krping_purge(struct cdev *dev __unused)
  218 {
  219 
  220         krping_cancel_all();
  221 }
  222 
  223 int
  224 krping_sigpending(void)
  225 {
  226 
  227         return (SIGPENDING(curthread));
  228 }
  229 
  230 DEV_MODULE(krping, krping_loader, NULL);
  231 MODULE_DEPEND(krping, ibcore, 1, 1, 1);

Cache object: 73d690c64d34781ed263a7530c242f9b

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/contrib/rdma/krping/krping_dev.c

FreeBSD/Linux Kernel Cross Reference
sys/contrib/rdma/krping/krping_dev.c