lustre/portals/include/linux/kp30.h

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  */
   4 #ifndef _KP30_INCLUDED
   5 #define _KP30_INCLUDED
   6
   7 #define PORTAL_DEBUG
   8
   9 #ifndef offsetof
  10 # define offsetof(typ,memb)     ((int)((char *)&(((typ *)0)->memb)))
  11 #endif
  12
  13 #define LOWEST_BIT_SET(x)       ((x) & ~((x) - 1))
  14
  15 /*
  16  *  Debugging
  17  */
  18 extern unsigned int portal_subsystem_debug;
  19 extern unsigned int portal_stack;
  20 extern unsigned int portal_debug;
  21 extern unsigned int portal_printk;
  22 extern unsigned int portal_cerror;
  23 /* Debugging subsystems (32 bits, non-overlapping) */
  24 #define S_UNDEFINED    (1 << 0)
  25 #define S_MDC          (1 << 1)
  26 #define S_MDS          (1 << 2)
  27 #define S_OSC          (1 << 3)
  28 #define S_OST          (1 << 4)
  29 #define S_CLASS        (1 << 5)
  30 #define S_LOG          (1 << 6)
  31 #define S_LLITE        (1 << 7)
  32 #define S_RPC          (1 << 8)
  33 #define S_MGMT         (1 << 9)
  34 #define S_PORTALS     (1 << 10)
  35 #define S_SOCKNAL     (1 << 11)
  36 #define S_QSWNAL      (1 << 12)
  37 #define S_PINGER      (1 << 13)
  38 #define S_FILTER      (1 << 14)
  39 #define S_PTLBD       (1 << 15)
  40 #define S_ECHO        (1 << 16)
  41 #define S_LDLM        (1 << 17)
  42 #define S_LOV         (1 << 18)
  43 #define S_GMNAL       (1 << 19)
  44 #define S_PTLROUTER   (1 << 20)
  45 #define S_COBD        (1 << 21)
  46 #define S_IBNAL       (1 << 22)
  47
  48 /* If you change these values, please keep portals/utils/debug.c
  49  * up to date! */
  50
  51 /* Debugging masks (32 bits, non-overlapping) */
  52 #define D_TRACE     (1 << 0) /* ENTRY/EXIT markers */
  53 #define D_INODE     (1 << 1)
  54 #define D_SUPER     (1 << 2)
  55 #define D_EXT2      (1 << 3) /* anything from ext2_debug */
  56 #define D_MALLOC    (1 << 4) /* print malloc, free information */
  57 #define D_CACHE     (1 << 5) /* cache-related items */
  58 #define D_INFO      (1 << 6) /* general information */
  59 #define D_IOCTL     (1 << 7) /* ioctl related information */
  60 #define D_BLOCKS    (1 << 8) /* ext2 block allocation */
  61 #define D_NET       (1 << 9) /* network communications */
  62 #define D_WARNING   (1 << 10) /* CWARN(...) == CDEBUG (D_WARNING, ...) */
  63 #define D_BUFFS     (1 << 11)
  64 #define D_OTHER     (1 << 12)
  65 #define D_DENTRY    (1 << 13)
  66 #define D_PORTALS   (1 << 14) /* ENTRY/EXIT markers */
  67 #define D_PAGE      (1 << 15) /* bulk page handling */
  68 #define D_DLMTRACE  (1 << 16)
  69 #define D_ERROR     (1 << 17) /* CERROR(...) == CDEBUG (D_ERROR, ...) */
  70 #define D_EMERG     (1 << 18) /* CEMERG(...) == CDEBUG (D_EMERG, ...) */
  71 #define D_HA        (1 << 19) /* recovery and failover */
  72 #define D_RPCTRACE  (1 << 20) /* for distributed debugging */
  73 #define D_VFSTRACE  (1 << 21)
  74
  75 #ifdef __KERNEL__
  76 # include <linux/sched.h> /* THREAD_SIZE */
  77 #else
  78 # ifndef THREAD_SIZE /* x86_64 has THREAD_SIZE in userspace */
  79 #  define THREAD_SIZE 8192
  80 # endif
  81 #endif
  82
  83 #define LUSTRE_TRACE_SIZE (THREAD_SIZE >> 5)
  84
  85 #ifdef __KERNEL__
  86 # ifdef  __ia64__
  87 #  define CDEBUG_STACK (THREAD_SIZE -                                      \
  88                         ((unsigned long)__builtin_dwarf_cfa() &            \
  89                          (THREAD_SIZE - 1)))
  90 # else
  91 #  define CDEBUG_STACK (THREAD_SIZE -                                      \
  92                         ((unsigned long)__builtin_frame_address(0) &       \
  93                          (THREAD_SIZE - 1)))
  94 # endif
  95
  96 #define CHECK_STACK(stack)                                                    \
  97         do {                                                                  \
  98                 if ((stack) > 3*THREAD_SIZE/4 && (stack) > portal_stack) {    \
  99                         portals_debug_msg(DEBUG_SUBSYSTEM, D_ERROR,           \
 100                                           __FILE__, __FUNCTION__, __LINE__,   \
 101                                           (stack),                            \
 102                                           "maximum lustre stack %u\n",        \
 103                                           portal_stack = (stack));            \
 104                       /*panic("LBUG");*/                                      \
 105                 }                                                             \
 106         } while (0)
 107 #else /* __KERNEL__ */
 108 #define CHECK_STACK(stack) do { } while(0)
 109 #define CDEBUG_STACK (0L)
 110 #endif /* __KERNEL__ */
 111
 112 #if 1
 113 #define CDEBUG(mask, format, a...)                                            \
 114 do {                                                                          \
 115         if (portal_cerror == 0)                                               \
 116                 break;                                                        \
 117         CHECK_STACK(CDEBUG_STACK);                                            \
 118         if (!(mask) || ((mask) & (D_ERROR | D_EMERG | D_WARNING)) ||          \
 119             (portal_debug & (mask) &&                                         \
 120              portal_subsystem_debug & DEBUG_SUBSYSTEM))                       \
 121                 portals_debug_msg(DEBUG_SUBSYSTEM, mask,                      \
 122                                   __FILE__, __FUNCTION__, __LINE__,           \
 123                                   CDEBUG_STACK, format, ## a);                \
 124 } while (0)
 125
 126 #define CWARN(format, a...) CDEBUG(D_WARNING, format, ## a)
 127 #define CERROR(format, a...) CDEBUG(D_ERROR, format, ## a)
 128 #define CEMERG(format, a...) CDEBUG(D_EMERG, format, ## a)
 129
 130 #define GOTO(label, rc)                                                 \
 131 do {                                                                    \
 132         long GOTO__ret = (long)(rc);                                    \
 133         CDEBUG(D_TRACE,"Process leaving via %s (rc=%lu : %ld : %lx)\n", \
 134                #label, (unsigned long)GOTO__ret, (signed long)GOTO__ret,\
 135                (signed long)GOTO__ret);                                 \
 136         goto label;                                                     \
 137 } while (0)
 138
 139 #define RETURN(rc)                                                      \
 140 do {                                                                    \
 141         typeof(rc) RETURN__ret = (rc);                                  \
 142         CDEBUG(D_TRACE, "Process leaving (rc=%lu : %ld : %lx)\n",       \
 143                (long)RETURN__ret, (long)RETURN__ret, (long)RETURN__ret);\
 144         return RETURN__ret;                                             \
 145 } while (0)
 146
 147 #define ENTRY                                                           \
 148 do {                                                                    \
 149         CDEBUG(D_TRACE, "Process entered\n");                           \
 150 } while (0)
 151
 152 #define EXIT                                                            \
 153 do {                                                                    \
 154         CDEBUG(D_TRACE, "Process leaving\n");                           \
 155 } while(0)
 156 #else
 157 #define CDEBUG(mask, format, a...)      do { } while (0)
 158 #define CWARN(format, a...)             do { } while (0)
 159 #define CERROR(format, a...)            printk("<3>" format, ## a)
 160 #define CEMERG(format, a...)            printk("<0>" format, ## a)
 161 #define GOTO(label, rc)                 do { (void)(rc); goto label; } while (0)
 162 #define RETURN(rc)                      return (rc)
 163 #define ENTRY                           do { } while (0)
 164 #define EXIT                            do { } while (0)
 165 #endif
 166
 167 #ifdef __KERNEL__
 168 # include <linux/vmalloc.h>
 169 # include <linux/time.h>
 170 # include <linux/slab.h>
 171 # include <linux/interrupt.h>
 172 # include <linux/highmem.h>
 173 # include <linux/module.h>
 174 # include <linux/version.h>
 175 # include <portals/lib-nal.h>
 176 # include <linux/smp_lock.h>
 177 # include <asm/atomic.h>
 178
 179 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 180 #define schedule_work schedule_task
 181 #define prepare_work(wq,cb,cbdata)                                            \
 182 do {                                                                          \
 183         INIT_TQUEUE((wq), 0, 0);                                              \
 184         PREPARE_TQUEUE((wq), (cb), (cbdata));                                 \
 185 } while (0)
 186
 187 #define ll_invalidate_inode_pages invalidate_inode_pages
 188 #define PageUptodate Page_Uptodate
 189 #define our_recalc_sigpending(current) recalc_sigpending(current)
 190 #define num_online_cpus() smp_num_cpus
 191 static inline void our_cond_resched(void)
 192 {
 193         if (current->need_resched)
 194                schedule ();
 195 }
 196 #define work_struct_t       struct tq_struct
 197
 198 #else
 199
 200 #define prepare_work(wq,cb,cbdata)                                            \
 201 do {                                                                          \
 202         INIT_WORK((wq), (void *)(cb), (void *)(cbdata));                      \
 203 } while (0)
 204 #define ll_invalidate_inode_pages(inode) invalidate_inode_pages((inode)->i_mapping)
 205 #define wait_on_page wait_on_page_locked
 206 #define our_recalc_sigpending(current) recalc_sigpending()
 207 #define strtok(a,b) strpbrk(a, b)
 208 static inline void our_cond_resched(void)
 209 {
 210         cond_resched();
 211 }
 212 #define work_struct_t      struct work_struct
 213
 214 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0) */
 215
 216 #ifdef PORTAL_DEBUG
 217 extern void kportal_assertion_failed(char *expr, char *file, const char *func,
 218                                      const int line);
 219 #define LASSERT(e) ((e) ? 0 : kportal_assertion_failed( #e , __FILE__,  \
 220                                                         __FUNCTION__, __LINE__))
 221 /* it would be great to dump_stack() here, but some kernels
 222  * export it as show_stack() and I can't be bothered to
 223  * proprely engage in that dance right now */
 224 #define LASSERTF(cond, fmt...)                                                \
 225         do {                                                                  \
 226                 if (unlikely(!(cond))) {                                      \
 227                         portals_debug_msg(0, D_EMERG,  __FILE__, __FUNCTION__,\
 228                                           __LINE__,  CDEBUG_STACK,            \
 229                                           "ASSERTION(" #cond ") failed:" fmt);\
 230                         LBUG();                                               \
 231                 }                                                             \
 232         } while (0)
 233
 234 #else
 235 #define LASSERT(e)
 236 #define LASSERTF(cond, fmt...) do { } while (0)
 237 #endif
 238
 239 #ifdef __arch_um__
 240 #define LBUG_WITH_LOC(file, func, line)                                 \
 241 do {                                                                    \
 242         CEMERG("LBUG - trying to dump log to /tmp/lustre-log\n");       \
 243         portals_debug_dumplog();                                        \
 244         portals_run_lbug_upcall(file, func, line);                      \
 245         panic("LBUG");                                                  \
 246 } while (0)
 247 #else
 248 #define LBUG_WITH_LOC(file, func, line)                                 \
 249 do {                                                                    \
 250         CEMERG("LBUG\n");                                               \
 251         portals_debug_dumplog();                                        \
 252         portals_run_lbug_upcall(file, func, line);                      \
 253         set_task_state(current, TASK_UNINTERRUPTIBLE);                  \
 254         schedule();                                                     \
 255 } while (0)
 256 #endif /* __arch_um__ */
 257
 258 #define LBUG() LBUG_WITH_LOC(__FILE__, __FUNCTION__, __LINE__)
 259
 260 /*
 261  * Memory
 262  */
 263 #ifdef PORTAL_DEBUG
 264 extern atomic_t portal_kmemory;
 265
 266 # define portal_kmem_inc(ptr, size)                                           \
 267 do {                                                                          \
 268         atomic_add(size, &portal_kmemory);                                    \
 269 } while (0)
 270
 271 # define portal_kmem_dec(ptr, size) do {                                      \
 272         atomic_sub(size, &portal_kmemory);                                    \
 273 } while (0)
 274
 275 #else
 276 # define portal_kmem_inc(ptr, size) do {} while (0)
 277 # define portal_kmem_dec(ptr, size) do {} while (0)
 278 #endif /* PORTAL_DEBUG */
 279
 280 #define PORTAL_VMALLOC_SIZE        16384
 281
 282 #define PORTAL_ALLOC_GFP(ptr, size, mask)                                 \
 283 do {                                                                      \
 284         LASSERT (!in_interrupt());                                        \
 285         if ((size) > PORTAL_VMALLOC_SIZE)                                 \
 286                 (ptr) = vmalloc(size);                                    \
 287         else                                                              \
 288                 (ptr) = kmalloc((size), (mask));                          \
 289         if ((ptr) == NULL) {                                              \
 290                 CERROR("PORTALS: out of memory at %s:%d (tried to alloc '"\
 291                        #ptr "' = %d)\n", __FILE__, __LINE__, (int)(size));\
 292                 CERROR("PORTALS: %d total bytes allocated by portals\n",  \
 293                        atomic_read(&portal_kmemory));                     \
 294         } else {                                                          \
 295                 portal_kmem_inc((ptr), (size));                           \
 296                 memset((ptr), 0, (size));                                 \
 297         }                                                                 \
 298         CDEBUG(D_MALLOC, "kmalloced '" #ptr "': %d at %p (tot %d).\n",    \
 299                (int)(size), (ptr), atomic_read (&portal_kmemory));        \
 300 } while (0)
 301
 302 #define PORTAL_ALLOC(ptr, size) \
 303         PORTAL_ALLOC_GFP(ptr, size, GFP_NOFS)
 304
 305 #define PORTAL_ALLOC_ATOMIC(ptr, size) \
 306         PORTAL_ALLOC_GFP(ptr, size, GFP_ATOMIC)
 307
 308 #define PORTAL_FREE(ptr, size)                                          \
 309 do {                                                                    \
 310         int s = (size);                                                 \
 311         if ((ptr) == NULL) {                                            \
 312                 CERROR("PORTALS: free NULL '" #ptr "' (%d bytes) at "   \
 313                        "%s:%d\n", s, __FILE__, __LINE__);               \
 314                 break;                                                  \
 315         }                                                               \
 316         if (s > PORTAL_VMALLOC_SIZE)                                    \
 317                 vfree(ptr);                                             \
 318         else                                                            \
 319                 kfree(ptr);                                             \
 320         portal_kmem_dec((ptr), s);                                      \
 321         CDEBUG(D_MALLOC, "kfreed '" #ptr "': %d at %p (tot %d).\n",     \
 322                s, (ptr), atomic_read(&portal_kmemory));                 \
 323 } while (0)
 324
 325 #define PORTAL_SLAB_ALLOC(ptr, slab, size)                                \
 326 do {                                                                      \
 327         LASSERT(!in_interrupt());                                         \
 328         (ptr) = kmem_cache_alloc((slab), SLAB_NOFS);                      \
 329         if ((ptr) == NULL) {                                              \
 330                 CERROR("PORTALS: out of memory at %s:%d (tried to alloc"  \
 331                        " '" #ptr "' from slab '" #slab "')\n", __FILE__,  \
 332                        __LINE__);                                         \
 333                 CERROR("PORTALS: %d total bytes allocated by portals\n",  \
 334                        atomic_read(&portal_kmemory));                     \
 335         } else {                                                          \
 336                 portal_kmem_inc((ptr), (size));                           \
 337                 memset((ptr), 0, (size));                                 \
 338         }                                                                 \
 339         CDEBUG(D_MALLOC, "kmalloced '" #ptr "': %d at %p (tot %d).\n",    \
 340                (int)(size), (ptr), atomic_read(&portal_kmemory));         \
 341 } while (0)
 342
 343 #define PORTAL_SLAB_FREE(ptr, slab, size)                               \
 344 do {                                                                    \
 345         int s = (size);                                                 \
 346         if ((ptr) == NULL) {                                            \
 347                 CERROR("PORTALS: free NULL '" #ptr "' (%d bytes) at "   \
 348                        "%s:%d\n", s, __FILE__, __LINE__);               \
 349                 break;                                                  \
 350         }                                                               \
 351         memset((ptr), 0x5a, s);                                         \
 352         kmem_cache_free((slab), ptr);                                   \
 353         portal_kmem_dec((ptr), s);                                      \
 354         CDEBUG(D_MALLOC, "kfreed '" #ptr "': %d at %p (tot %d).\n",     \
 355                s, (ptr), atomic_read (&portal_kmemory));                \
 356 } while (0)
 357
 358 /* ------------------------------------------------------------------- */
 359
 360 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 361
 362 #define PORTAL_SYMBOL_REGISTER(x) inter_module_register(#x, THIS_MODULE, &x)
 363 #define PORTAL_SYMBOL_UNREGISTER(x) inter_module_unregister(#x)
 364
 365 #define PORTAL_SYMBOL_GET(x) ((typeof(&x))inter_module_get(#x))
 366 #define PORTAL_SYMBOL_PUT(x) inter_module_put(#x)
 367
 368 #define PORTAL_MODULE_USE       MOD_INC_USE_COUNT
 369 #define PORTAL_MODULE_UNUSE     MOD_DEC_USE_COUNT
 370 #else
 371
 372 #define PORTAL_SYMBOL_REGISTER(x)
 373 #define PORTAL_SYMBOL_UNREGISTER(x)
 374
 375 #define PORTAL_SYMBOL_GET(x) symbol_get(x)
 376 #define PORTAL_SYMBOL_PUT(x) symbol_put(x)
 377
 378 #define PORTAL_MODULE_USE       try_module_get(THIS_MODULE)
 379 #define PORTAL_MODULE_UNUSE     module_put(THIS_MODULE)
 380
 381 #endif
 382
 383 /******************************************************************************/
 384 /* Kernel Portals Router interface */
 385
 386 typedef void (*kpr_fwd_callback_t)(void *arg, int error); // completion callback
 387
 388 /* space for routing targets to stash "stuff" in a forwarded packet */
 389 typedef union {
 390         long long        _alignment;
 391         void            *_space[16];            /* scale with CPU arch */
 392 } kprfd_scratch_t;
 393
 394 /* Kernel Portals Routing Forwarded message Descriptor */
 395 typedef struct {
 396         struct list_head     kprfd_list;        /* stash in queues (routing target can use) */
 397         ptl_nid_t            kprfd_target_nid;  /* final destination NID */
 398         ptl_nid_t            kprfd_gateway_nid; /* gateway NID */
 399         int                  kprfd_nob;         /* # message bytes (including header) */
 400         int                  kprfd_niov;        /* # message frags (including header) */
 401         struct iovec        *kprfd_iov;         /* message fragments */
 402         void                *kprfd_router_arg;  // originating NAL's router arg
 403         kpr_fwd_callback_t   kprfd_callback;    /* completion callback */
 404         void                *kprfd_callback_arg; /* completion callback arg */
 405         kprfd_scratch_t      kprfd_scratch;    // scratchpad for routing targets
 406 } kpr_fwd_desc_t;
 407
 408 typedef void  (*kpr_fwd_t)(void *arg, kpr_fwd_desc_t *fwd);
 409 typedef void  (*kpr_notify_t)(void *arg, ptl_nid_t peer, int alive);
 410
 411 /* NAL's routing interface (Kernel Portals Routing Nal Interface) */
 412 typedef const struct {
 413         int             kprni_nalid;    /* NAL's id */
 414         void           *kprni_arg;      /* Arg to pass when calling into NAL */
 415         kpr_fwd_t       kprni_fwd;      /* NAL's forwarding entrypoint */
 416         kpr_notify_t    kprni_notify;   /* NAL's notification entrypoint */
 417 } kpr_nal_interface_t;
 418
 419 /* Router's routing interface (Kernel Portals Routing Router Interface) */
 420 typedef const struct {
 421         /* register the calling NAL with the router and get back the handle for
 422          * subsequent calls */
 423         int     (*kprri_register) (kpr_nal_interface_t *nal_interface,
 424                                    void **router_arg);
 425
 426         /* ask the router to find a gateway that forwards to 'nid' and is a
 427          * peer of the calling NAL; assume caller will send 'nob' bytes of
 428          * payload there */
 429         int     (*kprri_lookup) (void *router_arg, ptl_nid_t nid, int nob,
 430                                  ptl_nid_t *gateway_nid);
 431
 432         /* hand a packet over to the router for forwarding */
 433         kpr_fwd_t kprri_fwd_start;
 434
 435         /* hand a packet back to the router for completion */
 436         void    (*kprri_fwd_done) (void *router_arg, kpr_fwd_desc_t *fwd,
 437                                    int error);
 438
 439         /* notify the router about peer state */
 440         void    (*kprri_notify) (void *router_arg, ptl_nid_t peer,
 441                                  int alive, time_t when);
 442
 443         /* the calling NAL is shutting down */
 444         void    (*kprri_shutdown) (void *router_arg);
 445
 446         /* deregister the calling NAL with the router */
 447         void    (*kprri_deregister) (void *router_arg);
 448
 449 } kpr_router_interface_t;
 450
 451 /* Convenient struct for NAL to stash router interface/args */
 452 typedef struct {
 453         kpr_router_interface_t  *kpr_interface;
 454         void                    *kpr_arg;
 455 } kpr_router_t;
 456
 457 /* Router's control interface (Kernel Portals Routing Control Interface) */
 458 typedef const struct {
 459         int     (*kprci_add_route)(int gateway_nal, ptl_nid_t gateway_nid,
 460                                    ptl_nid_t lo_nid, ptl_nid_t hi_nid);
 461         int     (*kprci_del_route)(int gateway_nal, ptl_nid_t gateway_nid,
 462                                    ptl_nid_t lo_nid, ptl_nid_t hi_nid);
 463         int     (*kprci_get_route)(int index, int *gateway_nal,
 464                                    ptl_nid_t *gateway,
 465                                    ptl_nid_t *lo_nid, ptl_nid_t *hi_nid,
 466                                    int *alive);
 467         int     (*kprci_notify)(int gateway_nal, ptl_nid_t gateway_nid,
 468                                 int alive, time_t when);
 469 } kpr_control_interface_t;
 470
 471 extern kpr_control_interface_t  kpr_control_interface;
 472 extern kpr_router_interface_t   kpr_router_interface;
 473
 474 static inline int
 475 kpr_register (kpr_router_t *router, kpr_nal_interface_t *nalif)
 476 {
 477         int    rc;
 478
 479         router->kpr_interface = PORTAL_SYMBOL_GET (kpr_router_interface);
 480         if (router->kpr_interface == NULL)
 481                 return (-ENOENT);
 482
 483         rc = (router->kpr_interface)->kprri_register (nalif, &router->kpr_arg);
 484         if (rc != 0)
 485                 router->kpr_interface = NULL;
 486
 487         PORTAL_SYMBOL_PUT (kpr_router_interface);
 488         return (rc);
 489 }
 490
 491 static inline int
 492 kpr_routing (kpr_router_t *router)
 493 {
 494         return (router->kpr_interface != NULL);
 495 }
 496
 497 static inline int
 498 kpr_lookup (kpr_router_t *router, ptl_nid_t nid, int nob, ptl_nid_t *gateway_nid)
 499 {
 500         if (!kpr_routing (router))
 501                 return (-ENETUNREACH);
 502
 503         return (router->kpr_interface->kprri_lookup(router->kpr_arg, nid, nob,
 504                                                     gateway_nid));
 505 }
 506
 507 static inline void
 508 kpr_fwd_init (kpr_fwd_desc_t *fwd, ptl_nid_t nid,
 509               int nob, int niov, struct iovec *iov,
 510               kpr_fwd_callback_t callback, void *callback_arg)
 511 {
 512         fwd->kprfd_target_nid   = nid;
 513         fwd->kprfd_gateway_nid  = nid;
 514         fwd->kprfd_nob          = nob;
 515         fwd->kprfd_niov         = niov;
 516         fwd->kprfd_iov          = iov;
 517         fwd->kprfd_callback     = callback;
 518         fwd->kprfd_callback_arg = callback_arg;
 519 }
 520
 521 static inline void
 522 kpr_fwd_start (kpr_router_t *router, kpr_fwd_desc_t *fwd)
 523 {
 524         if (!kpr_routing (router))
 525                 fwd->kprfd_callback (fwd->kprfd_callback_arg, -ENETUNREACH);
 526         else
 527                 router->kpr_interface->kprri_fwd_start (router->kpr_arg, fwd);
 528 }
 529
 530 static inline void
 531 kpr_fwd_done (kpr_router_t *router, kpr_fwd_desc_t *fwd, int error)
 532 {
 533         LASSERT (kpr_routing (router));
 534         router->kpr_interface->kprri_fwd_done (router->kpr_arg, fwd, error);
 535 }
 536
 537 static inline void
 538 kpr_notify (kpr_router_t *router,
 539             ptl_nid_t peer, int alive, time_t when)
 540 {
 541         if (!kpr_routing (router))
 542                 return;
 543
 544         router->kpr_interface->kprri_notify(router->kpr_arg, peer, alive, when);
 545 }
 546
 547 static inline void
 548 kpr_shutdown (kpr_router_t *router)
 549 {
 550         if (kpr_routing (router))
 551                 router->kpr_interface->kprri_shutdown (router->kpr_arg);
 552 }
 553
 554 static inline void
 555 kpr_deregister (kpr_router_t *router)
 556 {
 557         if (!kpr_routing (router))
 558                 return;
 559         router->kpr_interface->kprri_deregister (router->kpr_arg);
 560         router->kpr_interface = NULL;
 561 }
 562
 563 /******************************************************************************/
 564
 565 #ifdef PORTALS_PROFILING
 566 #define prof_enum(FOO) PROF__##FOO
 567 enum {
 568         prof_enum(our_recvmsg),
 569         prof_enum(our_sendmsg),
 570         prof_enum(socknal_recv),
 571         prof_enum(lib_parse),
 572         prof_enum(conn_list_walk),
 573         prof_enum(memcpy),
 574         prof_enum(lib_finalize),
 575         prof_enum(pingcli_time),
 576         prof_enum(gmnal_send),
 577         prof_enum(gmnal_recv),
 578         MAX_PROFS
 579 };
 580
 581 struct prof_ent {
 582         char *str;
 583         /* hrmph.  wrap-tastic. */
 584         u32       starts;
 585         u32       finishes;
 586         cycles_t  total_cycles;
 587         cycles_t  start;
 588         cycles_t  end;
 589 };
 590
 591 extern struct prof_ent prof_ents[MAX_PROFS];
 592
 593 #define PROF_START(FOO)                                         \
 594         do {                                                    \
 595                 struct prof_ent *pe = &prof_ents[PROF__##FOO];  \
 596                 pe->starts++;                                   \
 597                 pe->start = get_cycles();                       \
 598         } while (0)
 599
 600 #define PROF_FINISH(FOO)                                        \
 601         do {                                                    \
 602                 struct prof_ent *pe = &prof_ents[PROF__##FOO];  \
 603                 pe->finishes++;                                 \
 604                 pe->end = get_cycles();                         \
 605                 pe->total_cycles += (pe->end - pe->start);      \
 606         } while (0)
 607 #else /* !PORTALS_PROFILING */
 608 #define PROF_START(FOO) do {} while(0)
 609 #define PROF_FINISH(FOO) do {} while(0)
 610 #endif /* PORTALS_PROFILING */
 611
 612 /* debug.c */
 613 extern spinlock_t stack_backtrace_lock;
 614
 615 char *portals_debug_dumpstack(void);
 616 void portals_run_upcall(char **argv);
 617 void portals_run_lbug_upcall(char * file, const char *fn, const int line);
 618 void portals_debug_dumplog(void);
 619 int portals_debug_init(unsigned long bufsize);
 620 int portals_debug_cleanup(void);
 621 int portals_debug_clear_buffer(void);
 622 int portals_debug_mark_buffer(char *text);
 623 int portals_debug_set_daemon(unsigned int cmd, unsigned int length,
 624                              char *file, unsigned int size);
 625 __s32 portals_debug_copy_to_user(char *buf, unsigned long len);
 626 #if (__GNUC__)
 627 /* Use the special GNU C __attribute__ hack to have the compiler check the
 628  * printf style argument string against the actual argument count and
 629  * types.
 630  */
 631 #ifdef printf
 632 # warning printf has been defined as a macro...
 633 # undef printf
 634 #endif
 635 void portals_debug_msg(int subsys, int mask, char *file, const char *fn,
 636                        const int line, unsigned long stack,
 637                        char *format, ...)
 638         __attribute__ ((format (printf, 7, 8)));
 639 #else
 640 void portals_debug_msg(int subsys, int mask, char *file, const char *fn,
 641                        const int line, unsigned long stack,
 642                        const char *format, ...);
 643 #endif /* __GNUC__ */
 644 void portals_debug_set_level(unsigned int debug_level);
 645
 646 # define fprintf(a, format, b...) CDEBUG(D_OTHER, format , ## b)
 647 # define printf(format, b...) CDEBUG(D_OTHER, format , ## b)
 648 # define time(a) CURRENT_TIME
 649
 650 extern void kportal_daemonize (char *name);
 651 extern void kportal_blockallsigs (void);
 652
 653 #else  /* !__KERNEL__ */
 654 # include <stdio.h>
 655 # include <stdlib.h>
 656 #ifndef __CYGWIN__
 657 # include <stdint.h>
 658 #else
 659 # include <cygwin-ioctl.h>
 660 #endif
 661 # include <unistd.h>
 662 # include <time.h>
 663 # include <asm/types.h>
 664 # ifndef DEBUG_SUBSYSTEM
 665 #  define DEBUG_SUBSYSTEM S_UNDEFINED
 666 # endif
 667 # ifdef PORTAL_DEBUG
 668 #  undef NDEBUG
 669 #  include <assert.h>
 670 #  define LASSERT(e)     assert(e)
 671 #  define LASSERTF(cond, args...)     assert(cond)
 672 # else
 673 #  define LASSERT(e)
 674 #  define LASSERTF(cond, args...) do { } while (0)
 675 # endif
 676 # define printk(format, args...) printf (format, ## args)
 677 # define PORTAL_ALLOC(ptr, size) do { (ptr) = malloc(size); } while (0);
 678 # define PORTAL_FREE(a, b) do { free(a); } while (0);
 679 # define portals_debug_msg(subsys, mask, file, fn, line, stack, format, a...) \
 680     printf("%02x:%06x (@%lu %s:%s,l. %d %d %lu): " format,                    \
 681            (subsys), (mask), (long)time(0), file, fn, line,                   \
 682            getpid() , stack, ## a);
 683 #endif
 684
 685 /* support decl needed both by kernel and liblustre */
 686 char *portals_nid2str(int nal, ptl_nid_t nid, char *str);
 687
 688 #ifndef CURRENT_TIME
 689 # define CURRENT_TIME time(0)
 690 #endif
 691
 692 /******************************************************************************/
 693 /* Light-weight trace
 694  * Support for temporary event tracing with minimal Heisenberg effect. */
 695 #define LWT_SUPPORT  0
 696
 697 #define LWT_MEMORY   (64<<20)
 698 #define LWT_MAX_CPUS 4
 699
 700 typedef struct {
 701         cycles_t    lwte_when;
 702         char       *lwte_where;
 703         void       *lwte_task;
 704         long        lwte_p1;
 705         long        lwte_p2;
 706         long        lwte_p3;
 707         long        lwte_p4;
 708 #if BITS_PER_LONG > 32
 709         long        lwte_pad;
 710 #endif
 711 } lwt_event_t;
 712
 713 #if LWT_SUPPORT
 714 #ifdef __KERNEL__
 715 #define LWT_EVENTS_PER_PAGE (PAGE_SIZE / sizeof (lwt_event_t))
 716
 717 typedef struct _lwt_page {
 718         struct list_head     lwtp_list;
 719         struct page         *lwtp_page;
 720         lwt_event_t         *lwtp_events;
 721 } lwt_page_t;
 722
 723 typedef struct {
 724         int                lwtc_current_index;
 725         lwt_page_t        *lwtc_current_page;
 726 } lwt_cpu_t;
 727
 728 extern int       lwt_enabled;
 729 extern lwt_cpu_t lwt_cpus[];
 730
 731 extern int  lwt_init (void);
 732 extern void lwt_fini (void);
 733 extern int  lwt_lookup_string (int *size, char *knlptr,
 734                                char *usrptr, int usrsize);
 735 extern int  lwt_control (int enable, int clear);
 736 extern int  lwt_snapshot (cycles_t *now, int *ncpu, int *total_size,
 737                           void *user_ptr, int user_size);
 738
 739 /* Note that we _don't_ define LWT_EVENT at all if LWT_SUPPORT isn't set.
 740  * This stuff is meant for finding specific problems; it never stays in
 741  * production code... */
 742
 743 #define LWTSTR(n)       #n
 744 #define LWTWHERE(f,l)   f ":" LWTSTR(l)
 745
 746 #define LWT_EVENT(p1, p2, p3, p4)                                       \
 747 do {                                                                    \
 748         unsigned long    flags;                                         \
 749         lwt_cpu_t       *cpu;                                           \
 750         lwt_page_t      *p;                                             \
 751         lwt_event_t     *e;                                             \
 752                                                                         \
 753         local_irq_save (flags);                                         \
 754                                                                         \
 755         if (lwt_enabled) {                                              \
 756                 cpu = &lwt_cpus[smp_processor_id()];                    \
 757                 p = cpu->lwtc_current_page;                             \
 758                 e = &p->lwtp_events[cpu->lwtc_current_index++];         \
 759                                                                         \
 760                 if (cpu->lwtc_current_index >= LWT_EVENTS_PER_PAGE) {   \
 761                         cpu->lwtc_current_page =                        \
 762                                 list_entry (p->lwtp_list.next,          \
 763                                             lwt_page_t, lwtp_list);     \
 764                         cpu->lwtc_current_index = 0;                    \
 765                 }                                                       \
 766                                                                         \
 767                 e->lwte_when  = get_cycles();                           \
 768                 e->lwte_where = LWTWHERE(__FILE__,__LINE__);            \
 769                 e->lwte_task  = current;                                \
 770                 e->lwte_p1    = (long)(p1);                             \
 771                 e->lwte_p2    = (long)(p2);                             \
 772                 e->lwte_p3    = (long)(p3);                             \
 773                 e->lwte_p4    = (long)(p4);                             \
 774         }                                                               \
 775                                                                         \
 776         local_irq_restore (flags);                                      \
 777 } while (0)
 778 #else  /* __KERNEL__ */
 779 #define LWT_EVENT(p1,p2,p3,p4)     /* no userland implementation yet */
 780 #endif /* __KERNEL__ */
 781 #endif /* LWT_SUPPORT */
 782
 783 struct portals_device_userstate
 784 {
 785         int          pdu_memhog_pages;
 786         struct page *pdu_memhog_root_page;
 787 };
 788
 789 #include <linux/portals_lib.h>
 790
 791 /*
 792  * USER LEVEL STUFF BELOW
 793  */
 794
 795 #define PORTALS_CFG_VERSION 0x00010001;
 796
 797 struct portals_cfg {
 798         __u32 pcfg_version;
 799         __u32 pcfg_command;
 800
 801         __u32 pcfg_nal;
 802         __u32 pcfg_flags;
 803
 804         __u32 pcfg_gw_nal;
 805         __u64 pcfg_nid;
 806         __u64 pcfg_nid2;
 807         __u64 pcfg_nid3;
 808         __u32 pcfg_id;
 809         __u32 pcfg_misc;
 810         __u32 pcfg_fd;
 811         __u32 pcfg_count;
 812         __u32 pcfg_size;
 813         __u32 pcfg_wait;
 814
 815         __u32 pcfg_plen1; /* buffers in userspace */
 816         char *pcfg_pbuf1;
 817         __u32 pcfg_plen2; /* buffers in userspace */
 818         char *pcfg_pbuf2;
 819 };
 820
 821 #define PCFG_INIT(pcfg, cmd)                            \
 822 do {                                                    \
 823         memset(&pcfg, 0, sizeof(pcfg));                 \
 824         pcfg.pcfg_version = PORTALS_CFG_VERSION;        \
 825         pcfg.pcfg_command = (cmd);                      \
 826                                                         \
 827 } while (0)
 828
 829 #define PORTAL_IOCTL_VERSION 0x00010007
 830 #define PING_SYNC       0
 831 #define PING_ASYNC      1
 832
 833 struct portal_ioctl_data {
 834         __u32 ioc_len;
 835         __u32 ioc_version;
 836         __u64 ioc_nid;
 837         __u64 ioc_nid2;
 838         __u64 ioc_nid3;
 839         __u32 ioc_count;
 840         __u32 ioc_nal;
 841         __u32 ioc_nal_cmd;
 842         __u32 ioc_fd;
 843         __u32 ioc_id;
 844
 845         __u32 ioc_flags;
 846         __u32 ioc_size;
 847
 848         __u32 ioc_wait;
 849         __u32 ioc_timeout;
 850         __u32 ioc_misc;
 851
 852         __u32 ioc_inllen1;
 853         char *ioc_inlbuf1;
 854         __u32 ioc_inllen2;
 855         char *ioc_inlbuf2;
 856
 857         __u32 ioc_plen1; /* buffers in userspace */
 858         char *ioc_pbuf1;
 859         __u32 ioc_plen2; /* buffers in userspace */
 860         char *ioc_pbuf2;
 861
 862         char ioc_bulk[0];
 863 };
 864
 865 struct portal_ioctl_hdr {
 866         __u32 ioc_len;
 867         __u32 ioc_version;
 868 };
 869
 870 struct portals_debug_ioctl_data
 871 {
 872         struct portal_ioctl_hdr hdr;
 873         unsigned int subs;
 874         unsigned int debug;
 875 };
 876
 877 #define PORTAL_IOC_INIT(data)                           \
 878 do {                                                    \
 879         memset(&data, 0, sizeof(data));                 \
 880         data.ioc_version = PORTAL_IOCTL_VERSION;        \
 881         data.ioc_len = sizeof(data);                    \
 882 } while (0)
 883
 884 /* FIXME check conflict with lustre_lib.h */
 885 #define PTL_IOC_DEBUG_MASK             _IOWR('f', 250, long)
 886
 887 static inline int portal_ioctl_packlen(struct portal_ioctl_data *data)
 888 {
 889         int len = sizeof(*data);
 890         len += size_round(data->ioc_inllen1);
 891         len += size_round(data->ioc_inllen2);
 892         return len;
 893 }
 894
 895 static inline int portal_ioctl_is_invalid(struct portal_ioctl_data *data)
 896 {
 897         if (data->ioc_len > (1<<30)) {
 898                 CERROR ("PORTALS ioctl: ioc_len larger than 1<<30\n");
 899                 return 1;
 900         }
 901         if (data->ioc_inllen1 > (1<<30)) {
 902                 CERROR ("PORTALS ioctl: ioc_inllen1 larger than 1<<30\n");
 903                 return 1;
 904         }
 905         if (data->ioc_inllen2 > (1<<30)) {
 906                 CERROR ("PORTALS ioctl: ioc_inllen2 larger than 1<<30\n");
 907                 return 1;
 908         }
 909         if (data->ioc_inlbuf1 && !data->ioc_inllen1) {
 910                 CERROR ("PORTALS ioctl: inlbuf1 pointer but 0 length\n");
 911                 return 1;
 912         }
 913         if (data->ioc_inlbuf2 && !data->ioc_inllen2) {
 914                 CERROR ("PORTALS ioctl: inlbuf2 pointer but 0 length\n");
 915                 return 1;
 916         }
 917         if (data->ioc_pbuf1 && !data->ioc_plen1) {
 918                 CERROR ("PORTALS ioctl: pbuf1 pointer but 0 length\n");
 919                 return 1;
 920         }
 921         if (data->ioc_pbuf2 && !data->ioc_plen2) {
 922                 CERROR ("PORTALS ioctl: pbuf2 pointer but 0 length\n");
 923                 return 1;
 924         }
 925         if (data->ioc_plen1 && !data->ioc_pbuf1) {
 926                 CERROR ("PORTALS ioctl: plen1 nonzero but no pbuf1 pointer\n");
 927                 return 1;
 928         }
 929         if (data->ioc_plen2 && !data->ioc_pbuf2) {
 930                 CERROR ("PORTALS ioctl: plen2 nonzero but no pbuf2 pointer\n");
 931                 return 1;
 932         }
 933         if (portal_ioctl_packlen(data) != data->ioc_len ) {
 934                 CERROR ("PORTALS ioctl: packlen != ioc_len\n");
 935                 return 1;
 936         }
 937         if (data->ioc_inllen1 &&
 938             data->ioc_bulk[data->ioc_inllen1 - 1] != '\0') {
 939                 CERROR ("PORTALS ioctl: inlbuf1 not 0 terminated\n");
 940                 return 1;
 941         }
 942         if (data->ioc_inllen2 &&
 943             data->ioc_bulk[size_round(data->ioc_inllen1) +
 944                            data->ioc_inllen2 - 1] != '\0') {
 945                 CERROR ("PORTALS ioctl: inlbuf2 not 0 terminated\n");
 946                 return 1;
 947         }
 948         return 0;
 949 }
 950
 951 #ifndef __KERNEL__
 952 static inline int portal_ioctl_pack(struct portal_ioctl_data *data, char **pbuf,
 953                                     int max)
 954 {
 955         char *ptr;
 956         struct portal_ioctl_data *overlay;
 957         data->ioc_len = portal_ioctl_packlen(data);
 958         data->ioc_version = PORTAL_IOCTL_VERSION;
 959
 960         if (*pbuf && portal_ioctl_packlen(data) > max)
 961                 return 1;
 962         if (*pbuf == NULL) {
 963                 *pbuf = malloc(data->ioc_len);
 964         }
 965         if (!*pbuf)
 966                 return 1;
 967         overlay = (struct portal_ioctl_data *)*pbuf;
 968         memcpy(*pbuf, data, sizeof(*data));
 969
 970         ptr = overlay->ioc_bulk;
 971         if (data->ioc_inlbuf1)
 972                 LOGL(data->ioc_inlbuf1, data->ioc_inllen1, ptr);
 973         if (data->ioc_inlbuf2)
 974                 LOGL(data->ioc_inlbuf2, data->ioc_inllen2, ptr);
 975         if (portal_ioctl_is_invalid(overlay))
 976                 return 1;
 977
 978         return 0;
 979 }
 980 #else
 981 #include <asm/uaccess.h>
 982
 983 /* buffer MUST be at least the size of portal_ioctl_hdr */
 984 static inline int portal_ioctl_getdata(char *buf, char *end, void *arg)
 985 {
 986         struct portal_ioctl_hdr *hdr;
 987         struct portal_ioctl_data *data;
 988         int err;
 989         ENTRY;
 990
 991         hdr = (struct portal_ioctl_hdr *)buf;
 992         data = (struct portal_ioctl_data *)buf;
 993
 994         err = copy_from_user(buf, (void *)arg, sizeof(*hdr));
 995         if ( err ) {
 996                 EXIT;
 997                 return err;
 998         }
 999
1000         if (hdr->ioc_version != PORTAL_IOCTL_VERSION) {
1001                 CERROR ("PORTALS: version mismatch kernel vs application\n");
1002                 return -EINVAL;
1003         }
1004
1005         if (hdr->ioc_len + buf >= end) {
1006                 CERROR ("PORTALS: user buffer exceeds kernel buffer\n");
1007                 return -EINVAL;
1008         }
1009
1010
1011         if (hdr->ioc_len < sizeof(struct portal_ioctl_data)) {
1012                 CERROR ("PORTALS: user buffer too small for ioctl\n");
1013                 return -EINVAL;
1014         }
1015
1016         err = copy_from_user(buf, (void *)arg, hdr->ioc_len);
1017         if ( err ) {
1018                 EXIT;
1019                 return err;
1020         }
1021
1022         if (portal_ioctl_is_invalid(data)) {
1023                 CERROR ("PORTALS: ioctl not correctly formatted\n");
1024                 return -EINVAL;
1025         }
1026
1027         if (data->ioc_inllen1) {
1028                 data->ioc_inlbuf1 = &data->ioc_bulk[0];
1029         }
1030
1031         if (data->ioc_inllen2) {
1032                 data->ioc_inlbuf2 = &data->ioc_bulk[0] +
1033                         size_round(data->ioc_inllen1);
1034         }
1035
1036         EXIT;
1037         return 0;
1038 }
1039 #endif
1040
1041 /* ioctls for manipulating snapshots 30- */
1042 #define IOC_PORTAL_TYPE                   'e'
1043 #define IOC_PORTAL_MIN_NR                 30
1044
1045 #define IOC_PORTAL_PING                    _IOWR('e', 30, long)
1046 #define IOC_PORTAL_GET_DEBUG               _IOWR('e', 31, long)
1047 #define IOC_PORTAL_CLEAR_DEBUG             _IOWR('e', 32, long)
1048 #define IOC_PORTAL_MARK_DEBUG              _IOWR('e', 33, long)
1049 #define IOC_PORTAL_PANIC                   _IOWR('e', 34, long)
1050 #define IOC_PORTAL_NAL_CMD                 _IOWR('e', 35, long)
1051 #define IOC_PORTAL_GET_NID                 _IOWR('e', 36, long)
1052 #define IOC_PORTAL_FAIL_NID                _IOWR('e', 37, long)
1053 #define IOC_PORTAL_SET_DAEMON              _IOWR('e', 38, long)
1054 #define IOC_PORTAL_LWT_CONTROL             _IOWR('e', 39, long)
1055 #define IOC_PORTAL_LWT_SNAPSHOT            _IOWR('e', 40, long)
1056 #define IOC_PORTAL_LWT_LOOKUP_STRING       _IOWR('e', 41, long)
1057 #define IOC_PORTAL_MEMHOG                  _IOWR('e', 42, long)
1058 #define IOC_PORTAL_MAX_NR                             42
1059
1060 enum {
1061         QSWNAL  =  1,
1062         SOCKNAL,
1063         GMNAL,
1064         TOENAL,
1065         TCPNAL,
1066         SCIMACNAL,
1067         ROUTER,
1068         IBNAL,
1069         NAL_ENUM_END_MARKER
1070 };
1071
1072 #ifdef __KERNEL__
1073 extern ptl_handle_ni_t  kqswnal_ni;
1074 extern ptl_handle_ni_t  ksocknal_ni;
1075 extern ptl_handle_ni_t  ktoenal_ni;
1076 extern ptl_handle_ni_t  kgmnal_ni;
1077 extern ptl_handle_ni_t  kibnal_ni;
1078 extern ptl_handle_ni_t  kscimacnal_ni;
1079 #endif
1080
1081 #define PTL_NALFMT_SIZE         16
1082
1083 #define NAL_MAX_NR (NAL_ENUM_END_MARKER - 1)
1084
1085 #define NAL_CMD_REGISTER_PEER_FD     100
1086 #define NAL_CMD_CLOSE_CONNECTION     101
1087 #define NAL_CMD_REGISTER_MYNID       102
1088 #define NAL_CMD_PUSH_CONNECTION      103
1089 #define NAL_CMD_GET_CONN             104
1090 #define NAL_CMD_DEL_AUTOCONN         105
1091 #define NAL_CMD_ADD_AUTOCONN         106
1092 #define NAL_CMD_GET_AUTOCONN         107
1093 #define NAL_CMD_GET_TXDESC           108
1094 #define NAL_CMD_ADD_ROUTE            109
1095 #define NAL_CMD_DEL_ROUTE            110
1096 #define NAL_CMD_GET_ROUTE            111
1097 #define NAL_CMD_NOTIFY_ROUTER        112
1098
1099 enum {
1100         DEBUG_DAEMON_START       =  1,
1101         DEBUG_DAEMON_STOP        =  2,
1102         DEBUG_DAEMON_PAUSE       =  3,
1103         DEBUG_DAEMON_CONTINUE    =  4,
1104 };
1105
1106 /* XXX remove to lustre ASAP */
1107 struct lustre_peer {
1108         ptl_nid_t       peer_nid;
1109         ptl_handle_ni_t peer_ni;
1110 };
1111
1112
1113 /* module.c */
1114 typedef int (*nal_cmd_handler_t)(struct portals_cfg *, void * private);
1115 int kportal_nal_register(int nal, nal_cmd_handler_t handler, void * private);
1116 int kportal_nal_unregister(int nal);
1117
1118 enum cfg_record_type {
1119         PORTALS_CFG_TYPE = 1,
1120         LUSTRE_CFG_TYPE = 123,
1121 };
1122
1123 typedef int (*cfg_record_cb_t)(enum cfg_record_type, int len, void *data);
1124 int kportal_nal_cmd(struct portals_cfg *);
1125
1126 ptl_handle_ni_t *kportal_get_ni (int nal);
1127 void kportal_put_ni (int nal);
1128
1129 #ifdef __CYGWIN__
1130 # ifndef BITS_PER_LONG
1131 #  if (~0UL) == 0xffffffffUL
1132 #   define BITS_PER_LONG 32
1133 #  else
1134 #   define BITS_PER_LONG 64
1135 #  endif
1136 # endif
1137 #endif
1138
1139 #if defined(__x86_64__)
1140 # define LPU64 "%Lu"
1141 # define LPD64 "%Ld"
1142 # define LPX64 "%#Lx"
1143 # define LPSZ  "%lu"
1144 # define LPSSZ "%ld"
1145 #elif (BITS_PER_LONG == 32 || __WORDSIZE == 32)
1146 # define LPU64 "%Lu"
1147 # define LPD64 "%Ld"
1148 # define LPX64 "%#Lx"
1149 # define LPSZ  "%u"
1150 # define LPSSZ "%d"
1151 #elif (BITS_PER_LONG == 64 || __WORDSIZE == 64)
1152 # define LPU64 "%lu"
1153 # define LPD64 "%ld"
1154 # define LPX64 "%#lx"
1155 # define LPSZ  "%lu"
1156 # define LPSSZ "%ld"
1157 #endif
1158 #ifndef LPU64
1159 # error "No word size defined"
1160 #endif
1161
1162 #endif