module/spl/spl-generic.c

   1 /*
   2  *  This file is part of the SPL: Solaris Porting Layer.
   3  *
   4  *  Copyright (c) 2008 Lawrence Livermore National Security, LLC.
   5  *  Produced at Lawrence Livermore National Laboratory
   6  *  Written by:
   7  *          Brian Behlendorf <behlendorf1@llnl.gov>,
   8  *          Herb Wartens <wartens2@llnl.gov>,
   9  *          Jim Garlick <garlick@llnl.gov>
  10  *  UCRL-CODE-235197
  11  *
  12  *  This is free software; you can redistribute it and/or modify it
  13  *  under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This is distributed in the hope that it will be useful, but WITHOUT
  18  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20  *  for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License along
  23  *  with this program; if not, write to the Free Software Foundation, Inc.,
  24  *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  25  */
  26
  27 #include <sys/sysmacros.h>
  28 #include <sys/systeminfo.h>
  29 #include <sys/vmsystm.h>
  30 #include <sys/vnode.h>
  31 #include <sys/kmem.h>
  32 #include <sys/mutex.h>
  33 #include <sys/taskq.h>
  34 #include <sys/debug.h>
  35 #include <sys/proc.h>
  36 #include <sys/kstat.h>
  37 #include <sys/utsname.h>
  38 #include <sys/file.h>
  39 #include <linux/kmod.h>
  40
  41 #ifdef DEBUG_SUBSYSTEM
  42 #undef DEBUG_SUBSYSTEM
  43 #endif
  44
  45 #define DEBUG_SUBSYSTEM S_GENERIC
  46
  47 char spl_version[16] = "SPL v" SPL_META_VERSION;
  48
  49 long spl_hostid = 0;
  50 EXPORT_SYMBOL(spl_hostid);
  51
  52 char hw_serial[HW_HOSTID_LEN] = "<none>";
  53 EXPORT_SYMBOL(hw_serial);
  54
  55 int p0 = 0;
  56 EXPORT_SYMBOL(p0);
  57
  58 #ifndef HAVE_KALLSYMS_LOOKUP_NAME
  59 kallsyms_lookup_name_t spl_kallsyms_lookup_name_fn = SYMBOL_POISON;
  60 #endif
  61
  62 int
  63 highbit(unsigned long i)
  64 {
  65         register int h = 1;
  66         ENTRY;
  67
  68         if (i == 0)
  69                 RETURN(0);
  70 #if BITS_PER_LONG == 64
  71         if (i & 0xffffffff00000000ul) {
  72                 h += 32; i >>= 32;
  73         }
  74 #endif
  75         if (i & 0xffff0000) {
  76                 h += 16; i >>= 16;
  77         }
  78         if (i & 0xff00) {
  79                 h += 8; i >>= 8;
  80         }
  81         if (i & 0xf0) {
  82                 h += 4; i >>= 4;
  83         }
  84         if (i & 0xc) {
  85                 h += 2; i >>= 2;
  86         }
  87         if (i & 0x2) {
  88                 h += 1;
  89         }
  90         RETURN(h);
  91 }
  92 EXPORT_SYMBOL(highbit);
  93
  94 /*
  95  * Implementation of 64 bit division for 32-bit machines.
  96  */
  97 #if BITS_PER_LONG == 32
  98 uint64_t __udivdi3(uint64_t dividend, uint64_t divisor)
  99 {
 100 #if defined(HAVE_DIV64_64) /* 2.6.22 - 2.6.25 API */
 101         return div64_64(dividend, divisor);
 102 #elif defined(HAVE_DIV64_U64) /* 2.6.26 - 2.6.x API */
 103         return div64_u64(dividend, divisor);
 104 #else
 105         /* Implementation from 2.6.30 kernel */
 106         uint32_t high, d;
 107
 108         high = divisor >> 32;
 109         if (high) {
 110                 unsigned int shift = fls(high);
 111
 112                 d = divisor >> shift;
 113                 dividend >>= shift;
 114         } else
 115                 d = divisor;
 116
 117         return do_div(dividend, d);
 118 #endif /* HAVE_DIV64_64, HAVE_DIV64_U64 */
 119 }
 120 EXPORT_SYMBOL(__udivdi3);
 121
 122 /*
 123  * Implementation of 64 bit modulo for 32-bit machines.
 124  */
 125 uint64_t __umoddi3(uint64_t dividend, uint64_t divisor)
 126 {
 127         return dividend - divisor * (dividend / divisor);
 128 }
 129 EXPORT_SYMBOL(__umoddi3);
 130 #endif /* BITS_PER_LONG */
 131
 132 /* NOTE: The strtoxx behavior is solely based on my reading of the Solaris
 133  * ddi_strtol(9F) man page.  I have not verified the behavior of these
 134  * functions against their Solaris counterparts.  It is possible that I
 135  * may have misinterpreted the man page or the man page is incorrect.
 136  */
 137 int ddi_strtoul(const char *, char **, int, unsigned long *);
 138 int ddi_strtol(const char *, char **, int, long *);
 139 int ddi_strtoull(const char *, char **, int, unsigned long long *);
 140 int ddi_strtoll(const char *, char **, int, long long *);
 141
 142 #define define_ddi_strtoux(type, valtype)                               \
 143 int ddi_strtou##type(const char *str, char **endptr,                    \
 144                      int base, valtype *result)                         \
 145 {                                                                       \
 146         valtype last_value, value = 0;                                  \
 147         char *ptr = (char *)str;                                        \
 148         int flag = 1, digit;                                            \
 149                                                                         \
 150         if (strlen(ptr) == 0)                                           \
 151                 return EINVAL;                                          \
 152                                                                         \
 153         /* Auto-detect base based on prefix */                          \
 154         if (!base) {                                                    \
 155                 if (str[0] == '0') {                                    \
 156                         if (tolower(str[1])=='x' && isxdigit(str[2])) { \
 157                                 base = 16; /* hex */                    \
 158                                 ptr += 2;                               \
 159                         } else if (str[1] >= '0' && str[1] < 8) {       \
 160                                 base = 8; /* octal */                   \
 161                                 ptr += 1;                               \
 162                         } else {                                        \
 163                                 return EINVAL;                          \
 164                         }                                               \
 165                 } else {                                                \
 166                         base = 10; /* decimal */                        \
 167                 }                                                       \
 168         }                                                               \
 169                                                                         \
 170         while (1) {                                                     \
 171                 if (isdigit(*ptr))                                      \
 172                         digit = *ptr - '0';                             \
 173                 else if (isalpha(*ptr))                                 \
 174                         digit = tolower(*ptr) - 'a' + 10;               \
 175                 else                                                    \
 176                         break;                                          \
 177                                                                         \
 178                 if (digit >= base)                                      \
 179                         break;                                          \
 180                                                                         \
 181                 last_value = value;                                     \
 182                 value = value * base + digit;                           \
 183                 if (last_value > value) /* Overflow */                  \
 184                         return ERANGE;                                  \
 185                                                                         \
 186                 flag = 1;                                               \
 187                 ptr++;                                                  \
 188         }                                                               \
 189                                                                         \
 190         if (flag)                                                       \
 191                 *result = value;                                        \
 192                                                                         \
 193         if (endptr)                                                     \
 194                 *endptr = (char *)(flag ? ptr : str);                   \
 195                                                                         \
 196         return 0;                                                       \
 197 }                                                                       \
 198
 199 #define define_ddi_strtox(type, valtype)                                \
 200 int ddi_strto##type(const char *str, char **endptr,                     \
 201                        int base, valtype *result)                       \
 202 {                                                                       \
 203         int rc;                                                         \
 204                                                                         \
 205         if (*str == '-') {                                              \
 206                 rc = ddi_strtou##type(str + 1, endptr, base, result);   \
 207                 if (!rc) {                                              \
 208                         if (*endptr == str + 1)                         \
 209                                 *endptr = (char *)str;                  \
 210                         else                                            \
 211                                 *result = -*result;                     \
 212                 }                                                       \
 213         } else {                                                        \
 214                 rc = ddi_strtou##type(str, endptr, base, result);       \
 215         }                                                               \
 216                                                                         \
 217         return rc;                                                      \
 218 }
 219
 220 define_ddi_strtoux(l, unsigned long)
 221 define_ddi_strtox(l, long)
 222 define_ddi_strtoux(ll, unsigned long long)
 223 define_ddi_strtox(ll, long long)
 224
 225 EXPORT_SYMBOL(ddi_strtoul);
 226 EXPORT_SYMBOL(ddi_strtol);
 227 EXPORT_SYMBOL(ddi_strtoll);
 228 EXPORT_SYMBOL(ddi_strtoull);
 229
 230 int
 231 ddi_copyin(const void *from, void *to, size_t len, int flags)
 232 {
 233         /* Fake ioctl() issued by kernel, 'from' is a kernel address */
 234         if (flags & FKIOCTL) {
 235                 memcpy(to, from, len);
 236                 return 0;
 237         }
 238
 239         return copyin(from, to, len);
 240 }
 241 EXPORT_SYMBOL(ddi_copyin);
 242
 243 int
 244 ddi_copyout(const void *from, void *to, size_t len, int flags)
 245 {
 246         /* Fake ioctl() issued by kernel, 'from' is a kernel address */
 247         if (flags & FKIOCTL) {
 248                 memcpy(to, from, len);
 249                 return 0;
 250         }
 251
 252         return copyout(from, to, len);
 253 }
 254 EXPORT_SYMBOL(ddi_copyout);
 255
 256 struct new_utsname *__utsname(void)
 257 {
 258 #ifdef HAVE_INIT_UTSNAME
 259         return init_utsname();
 260 #else
 261         return &system_utsname;
 262 #endif
 263 }
 264 EXPORT_SYMBOL(__utsname);
 265
 266 static int
 267 set_hostid(void)
 268 {
 269         char sh_path[] = "/bin/sh";
 270         char *argv[] = { sh_path,
 271                          "-c",
 272                          "/usr/bin/hostid >/proc/sys/kernel/spl/hostid",
 273                          NULL };
 274         char *envp[] = { "HOME=/",
 275                          "TERM=linux",
 276                          "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
 277                          NULL };
 278         int rc;
 279
 280         /* Doing address resolution in the kernel is tricky and just
 281          * not a good idea in general.  So to set the proper 'hw_serial'
 282          * use the usermodehelper support to ask '/bin/sh' to run
 283          * '/usr/bin/hostid' and redirect the result to /proc/sys/spl/hostid
 284          * for us to use.  It's a horrific solution but it will do for now.
 285          */
 286         rc = call_usermodehelper(sh_path, argv, envp, 1);
 287         if (rc)
 288                 printk("SPL: Failed user helper '%s %s %s', rc = %d\n",
 289                        argv[0], argv[1], argv[2], rc);
 290
 291         return rc;
 292 }
 293
 294 uint32_t
 295 zone_get_hostid(void *zone)
 296 {
 297         unsigned long hostid;
 298
 299         /* Only the global zone is supported */
 300         ASSERT(zone == NULL);
 301
 302         if (ddi_strtoul(hw_serial, NULL, HW_HOSTID_LEN-1, &hostid) != 0)
 303                 return HW_INVALID_HOSTID;
 304
 305         return (uint32_t)hostid;
 306 }
 307 EXPORT_SYMBOL(zone_get_hostid);
 308
 309 #ifndef HAVE_KALLSYMS_LOOKUP_NAME
 310 /*
 311  * Because kallsyms_lookup_name() is no longer exported in the
 312  * mainline kernel we are forced to resort to somewhat drastic
 313  * measures.  This function replaces the functionality by performing
 314  * an upcall to user space where /proc/kallsyms is consulted for
 315  * the requested address.
 316  */
 317 #define GET_KALLSYMS_ADDR_CMD                                           \
 318         "awk '{ if ( $3 == \"kallsyms_lookup_name\") { print $1 } }' "  \
 319         "/proc/kallsyms >/proc/sys/kernel/spl/kallsyms_lookup_name"
 320
 321 static int
 322 set_kallsyms_lookup_name(void)
 323 {
 324         char sh_path[] = "/bin/sh";
 325         char *argv[] = { sh_path,
 326                          "-c",
 327                          GET_KALLSYMS_ADDR_CMD,
 328                          NULL };
 329         char *envp[] = { "HOME=/",
 330                          "TERM=linux",
 331                          "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
 332                          NULL };
 333         int rc;
 334
 335         rc = call_usermodehelper(sh_path, argv, envp, 1);
 336         if (rc)
 337                 printk("SPL: Failed user helper '%s %s %s', rc = %d\n",
 338                        argv[0], argv[1], argv[2], rc);
 339
 340         return rc;
 341 }
 342 #endif
 343
 344 static int __init spl_init(void)
 345 {
 346         int rc = 0;
 347
 348         if ((rc = debug_init()))
 349                 return rc;
 350
 351         if ((rc = spl_kmem_init()))
 352                 GOTO(out , rc);
 353
 354         if ((rc = spl_mutex_init()))
 355                 GOTO(out2 , rc);
 356
 357         if ((rc = spl_taskq_init()))
 358                 GOTO(out3, rc);
 359
 360         if ((rc = vn_init()))
 361                 GOTO(out4, rc);
 362
 363         if ((rc = proc_init()))
 364                 GOTO(out5, rc);
 365
 366         if ((rc = kstat_init()))
 367                 GOTO(out6, rc);
 368
 369         if ((rc = set_hostid()))
 370                 GOTO(out7, rc = -EADDRNOTAVAIL);
 371
 372 #ifndef HAVE_KALLSYMS_LOOKUP_NAME
 373         if ((rc = set_kallsyms_lookup_name()))
 374                 GOTO(out7, rc = -EADDRNOTAVAIL);
 375 #endif /* HAVE_KALLSYMS_LOOKUP_NAME */
 376
 377         if ((rc = spl_kmem_init_kallsyms_lookup()))
 378                 GOTO(out7, rc);
 379
 380         printk("SPL: Loaded Solaris Porting Layer v%s\n", SPL_META_VERSION);
 381         RETURN(rc);
 382 out7:
 383         kstat_fini();
 384 out6:
 385         proc_fini();
 386 out5:
 387         vn_fini();
 388 out4:
 389         spl_taskq_fini();
 390 out3:
 391         spl_mutex_fini();
 392 out2:
 393         spl_kmem_fini();
 394 out:
 395         debug_fini();
 396
 397         printk("SPL: Failed to Load Solaris Porting Layer v%s, "
 398                "rc = %d\n", SPL_META_VERSION, rc);
 399         return rc;
 400 }
 401
 402 static void spl_fini(void)
 403 {
 404         ENTRY;
 405
 406         printk("SPL: Unloaded Solaris Porting Layer v%s\n", SPL_META_VERSION);
 407         kstat_fini();
 408         proc_fini();
 409         vn_fini();
 410         spl_taskq_fini();
 411         spl_mutex_fini();
 412         spl_kmem_fini();
 413         debug_fini();
 414 }
 415
 416 module_init(spl_init);
 417 module_exit(spl_fini);
 418
 419 MODULE_AUTHOR("Lawrence Livermore National Labs");
 420 MODULE_DESCRIPTION("Solaris Porting Layer");
 421 MODULE_LICENSE("GPL");