module/spl/spl-generic.c

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