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 <linux/kmod.h>
  39
  40 #ifdef DEBUG_SUBSYSTEM
  41 #undef DEBUG_SUBSYSTEM
  42 #endif
  43
  44 #define DEBUG_SUBSYSTEM S_GENERIC
  45
  46 char spl_version[16] = "SPL v" VERSION;
  47
  48 long spl_hostid = 0;
  49 EXPORT_SYMBOL(spl_hostid);
  50
  51 char hw_serial[HW_HOSTID_LEN] = "<none>";
  52 EXPORT_SYMBOL(hw_serial);
  53
  54 int p0 = 0;
  55 EXPORT_SYMBOL(p0);
  56
  57 #ifndef HAVE_KALLSYMS_LOOKUP_NAME
  58 kallsyms_lookup_name_t spl_kallsyms_lookup_name_fn = NULL;
  59 #endif
  60
  61 int
  62 highbit(unsigned long i)
  63 {
  64         register int h = 1;
  65         ENTRY;
  66
  67         if (i == 0)
  68                 RETURN(0);
  69 #if BITS_PER_LONG == 64
  70         if (i & 0xffffffff00000000ul) {
  71                 h += 32; i >>= 32;
  72         }
  73 #endif
  74         if (i & 0xffff0000) {
  75                 h += 16; i >>= 16;
  76         }
  77         if (i & 0xff00) {
  78                 h += 8; i >>= 8;
  79         }
  80         if (i & 0xf0) {
  81                 h += 4; i >>= 4;
  82         }
  83         if (i & 0xc) {
  84                 h += 2; i >>= 2;
  85         }
  86         if (i & 0x2) {
  87                 h += 1;
  88         }
  89         RETURN(h);
  90 }
  91 EXPORT_SYMBOL(highbit);
  92
  93 /*
  94  * Implementation of 64 bit division for 32-bit machines.
  95  */
  96 #if BITS_PER_LONG == 32
  97 uint64_t __udivdi3(uint64_t dividend, uint64_t divisor)
  98 {
  99 #ifdef HAVE_DIV64_64
 100         return div64_64(dividend, divisor);
 101 #else
 102         /* Taken from a 2.6.24 kernel. */
 103         uint32_t high, d;
 104
 105         high = divisor >> 32;
 106         if (high) {
 107                 unsigned int shift = fls(high);
 108
 109                 d = divisor >> shift;
 110                 dividend >>= shift;
 111         } else
 112                 d = divisor;
 113
 114         do_div(dividend, d);
 115
 116         return dividend;
 117 #endif
 118 }
 119 EXPORT_SYMBOL(__udivdi3);
 120
 121 /*
 122  * Implementation of 64 bit modulo for 32-bit machines.
 123  */
 124 uint64_t __umoddi3(uint64_t dividend, uint64_t divisor)
 125 {
 126         return dividend - divisor * (dividend / divisor);
 127 }
 128 EXPORT_SYMBOL(__umoddi3);
 129 #endif
 130
 131 /* NOTE: The strtoxx behavior is solely based on my reading of the Solaris
 132  * ddi_strtol(9F) man page.  I have not verified the behavior of these
 133  * functions against their Solaris counterparts.  It is possible that I
 134  * may have misinterpretted the man page or the man page is incorrect.
 135  */
 136 int ddi_strtoul(const char *, char **, int, unsigned long *);
 137 int ddi_strtol(const char *, char **, int, long *);
 138 int ddi_strtoull(const char *, char **, int, unsigned long long *);
 139 int ddi_strtoll(const char *, char **, int, long long *);
 140
 141 #define define_ddi_strtoux(type, valtype)                               \
 142 int ddi_strtou##type(const char *str, char **endptr,                    \
 143                      int base, valtype *result)                         \
 144 {                                                                       \
 145         valtype last_value, value = 0;                                  \
 146         char *ptr = (char *)str;                                        \
 147         int flag = 1, digit;                                            \
 148                                                                         \
 149         if (strlen(ptr) == 0)                                           \
 150                 return EINVAL;                                          \
 151                                                                         \
 152         /* Auto-detect base based on prefix */                          \
 153         if (!base) {                                                    \
 154                 if (str[0] == '0') {                                    \
 155                         if (tolower(str[1])=='x' && isxdigit(str[2])) { \
 156                                 base = 16; /* hex */                    \
 157                                 ptr += 2;                               \
 158                         } else if (str[1] >= '0' && str[1] < 8) {       \
 159                                 base = 8; /* octal */                   \
 160                                 ptr += 1;                               \
 161                         } else {                                        \
 162                                 return EINVAL;                          \
 163                         }                                               \
 164                 } else {                                                \
 165                         base = 10; /* decimal */                        \
 166                 }                                                       \
 167         }                                                               \
 168                                                                         \
 169         while (1) {                                                     \
 170                 if (isdigit(*ptr))                                      \
 171                         digit = *ptr - '0';                             \
 172                 else if (isalpha(*ptr))                                 \
 173                         digit = tolower(*ptr) - 'a' + 10;               \
 174                 else                                                    \
 175                         break;                                          \
 176                                                                         \
 177                 if (digit >= base)                                      \
 178                         break;                                          \
 179                                                                         \
 180                 last_value = value;                                     \
 181                 value = value * base + digit;                           \
 182                 if (last_value > value) /* Overflow */                  \
 183                         return ERANGE;                                  \
 184                                                                         \
 185                 flag = 1;                                               \
 186                 ptr++;                                                  \
 187         }                                                               \
 188                                                                         \
 189         if (flag)                                                       \
 190                 *result = value;                                        \
 191                                                                         \
 192         if (endptr)                                                     \
 193                 *endptr = (char *)(flag ? ptr : str);                   \
 194                                                                         \
 195         return 0;                                                       \
 196 }                                                                       \
 197
 198 #define define_ddi_strtox(type, valtype)                                \
 199 int ddi_strto##type(const char *str, char **endptr,                     \
 200                        int base, valtype *result)                       \
 201 {                                                                       \
 202         int rc;                                                         \
 203                                                                         \
 204         if (*str == '-') {                                              \
 205                 rc = ddi_strtou##type(str + 1, endptr, base, result);   \
 206                 if (!rc) {                                              \
 207                         if (*endptr == str + 1)                         \
 208                                 *endptr = (char *)str;                  \
 209                         else                                            \
 210                                 *result = -*result;                     \
 211                 }                                                       \
 212         } else {                                                        \
 213                 rc = ddi_strtou##type(str, endptr, base, result);       \
 214         }                                                               \
 215                                                                         \
 216         return rc;                                                      \
 217 }
 218
 219 define_ddi_strtoux(l, unsigned long)
 220 define_ddi_strtox(l, long)
 221 define_ddi_strtoux(ll, unsigned long long)
 222 define_ddi_strtox(ll, long long)
 223
 224 EXPORT_SYMBOL(ddi_strtoul);
 225 EXPORT_SYMBOL(ddi_strtol);
 226 EXPORT_SYMBOL(ddi_strtoll);
 227 EXPORT_SYMBOL(ddi_strtoull);
 228
 229 struct new_utsname *__utsname(void)
 230 {
 231 #ifdef HAVE_INIT_UTSNAME
 232         return init_utsname();
 233 #else
 234         return &system_utsname;
 235 #endif
 236 }
 237 EXPORT_SYMBOL(__utsname);
 238
 239 static int
 240 set_hostid(void)
 241 {
 242         char sh_path[] = "/bin/sh";
 243         char *argv[] = { sh_path,
 244                          "-c",
 245                          "/usr/bin/hostid >/proc/sys/kernel/spl/hostid",
 246                          NULL };
 247         char *envp[] = { "HOME=/",
 248                          "TERM=linux",
 249                          "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
 250                          NULL };
 251
 252         /* Doing address resolution in the kernel is tricky and just
 253          * not a good idea in general.  So to set the proper 'hw_serial'
 254          * use the usermodehelper support to ask '/bin/sh' to run
 255          * '/usr/bin/hostid' and redirect the result to /proc/sys/spl/hostid
 256          * for us to use.  It's a horific solution but it will do for now.
 257          */
 258         return call_usermodehelper(sh_path, argv, envp, 1);
 259 }
 260
 261 uint32_t
 262 zone_get_hostid(void *zone)
 263 {
 264         unsigned long hostid;
 265
 266         /* Only the global zone is supported */
 267         ASSERT(zone == NULL);
 268
 269         if (ddi_strtoul(hw_serial, NULL, HW_HOSTID_LEN-1, &hostid) != 0)
 270                 return HW_INVALID_HOSTID;
 271
 272         return (uint32_t)hostid;
 273 }
 274 EXPORT_SYMBOL(zone_get_hostid);
 275
 276 #ifdef HAVE_KALLSYMS_LOOKUP_NAME
 277 #define set_kallsyms_lookup_name()      (0)
 278 #else
 279 /*
 280  * Because kallsyms_lookup_name() is no longer exported in the
 281  * mainline kernel we are forced to resort to somewhat drastic
 282  * measures.  This function replaces the functionality by performing
 283  * an upcall to user space where /proc/kallsyms is consulted for
 284  * the requested address.
 285  */
 286 #define GET_KALLSYMS_ADDR_CMD                                           \
 287         "awk '{ if ( $3 == \"kallsyms_lookup_name\") { print $1 } }' "  \
 288         "/proc/kallsyms >/proc/sys/kernel/spl/kallsyms_lookup_name"
 289
 290 static int
 291 set_kallsyms_lookup_name(void)
 292 {
 293         char sh_path[] = "/bin/sh";
 294         char *argv[] = { sh_path,
 295                          "-c",
 296                          GET_KALLSYMS_ADDR_CMD,
 297                          NULL };
 298         char *envp[] = { "HOME=/",
 299                          "TERM=linux",
 300                          "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
 301                          NULL };
 302         int rc;
 303
 304         rc = call_usermodehelper(sh_path, argv, envp, 1);
 305         if (rc)
 306                 return rc;
 307
 308         return spl_kmem_init_kallsyms_lookup();
 309 }
 310 #endif
 311
 312 static int __init spl_init(void)
 313 {
 314         int rc = 0;
 315
 316         if ((rc = debug_init()))
 317                 return rc;
 318
 319         if ((rc = spl_kmem_init()))
 320                 GOTO(out , rc);
 321
 322         if ((rc = spl_mutex_init()))
 323                 GOTO(out2 , rc);
 324
 325         if ((rc = spl_taskq_init()))
 326                 GOTO(out3, rc);
 327
 328         if ((rc = vn_init()))
 329                 GOTO(out4, rc);
 330
 331         if ((rc = proc_init()))
 332                 GOTO(out5, rc);
 333
 334         if ((rc = kstat_init()))
 335                 GOTO(out6, rc);
 336
 337         if ((rc = set_hostid()))
 338                 GOTO(out7, rc = -EADDRNOTAVAIL);
 339
 340         if ((rc = set_kallsyms_lookup_name()))
 341                 GOTO(out7, rc = -EADDRNOTAVAIL);
 342
 343         printk("SPL: Loaded Solaris Porting Layer v%s\n", VERSION);
 344         RETURN(rc);
 345 out7:
 346         kstat_fini();
 347 out6:
 348         proc_fini();
 349 out5:
 350         vn_fini();
 351 out4:
 352         spl_taskq_fini();
 353 out3:
 354         spl_mutex_fini();
 355 out2:
 356         spl_kmem_fini();
 357 out:
 358         debug_fini();
 359
 360         printk("SPL: Failed to Load Solaris Porting Layer v%s, "
 361                "rc = %d\n", VERSION, rc);
 362         return rc;
 363 }
 364
 365 static void spl_fini(void)
 366 {
 367         ENTRY;
 368
 369         printk("SPL: Unloaded Solaris Porting Layer v%s\n", VERSION);
 370         kstat_fini();
 371         proc_fini();
 372         vn_fini();
 373         spl_taskq_fini();
 374         spl_mutex_fini();
 375         spl_kmem_fini();
 376         debug_fini();
 377 }
 378
 379 module_init(spl_init);
 380 module_exit(spl_fini);
 381
 382 MODULE_AUTHOR("Lawrence Livermore National Labs");
 383 MODULE_DESCRIPTION("Solaris Porting Layer");
 384 MODULE_LICENSE("GPL");