sys/dev/cpuctl/cpuctl.c

   1 /*-
   2  * Copyright (c) 2006-2008 Stanislav Sedov <stas@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/conf.h>
  34 #include <sys/fcntl.h>
  35 #include <sys/ioccom.h>
  36 #include <sys/malloc.h>
  37 #include <sys/module.h>
  38 #include <sys/mutex.h>
  39 #include <sys/priv.h>
  40 #include <sys/proc.h>
  41 #include <sys/queue.h>
  42 #include <sys/sched.h>
  43 #include <sys/kernel.h>
  44 #include <sys/sysctl.h>
  45 #include <sys/uio.h>
  46 #include <sys/pcpu.h>
  47 #include <sys/smp.h>
  48 #include <sys/pmckern.h>
  49 #include <sys/cpuctl.h>
  50
  51 #include <machine/cpufunc.h>
  52 #include <machine/md_var.h>
  53 #include <machine/specialreg.h>
  54
  55 static d_open_t cpuctl_open;
  56 static d_ioctl_t cpuctl_ioctl;
  57
  58 #define CPUCTL_VERSION 1
  59
  60 #ifdef DEBUG
  61 # define        DPRINTF(format,...) printf(format, __VA_ARGS__);
  62 #else
  63 # define        DPRINTF(...)
  64 #endif
  65
  66 #define UCODE_SIZE_MAX  (10 * 1024)
  67
  68 static int cpuctl_do_msr(int cpu, cpuctl_msr_args_t *data, u_long cmd,
  69     struct thread *td);
  70 static int cpuctl_do_cpuid(int cpu, cpuctl_cpuid_args_t *data,
  71     struct thread *td);
  72 static int cpuctl_do_update(int cpu, cpuctl_update_args_t *data,
  73     struct thread *td);
  74 static int update_intel(int cpu, cpuctl_update_args_t *args,
  75     struct thread *td);
  76 static int update_amd(int cpu, cpuctl_update_args_t *args, struct thread *td);
  77
  78 static struct cdev **cpuctl_devs;
  79 static MALLOC_DEFINE(M_CPUCTL, "cpuctl", "CPUCTL buffer");
  80
  81 static struct cdevsw cpuctl_cdevsw = {
  82         .d_version =    D_VERSION,
  83         .d_flags =      0,
  84         .d_open =       cpuctl_open,
  85         .d_ioctl =      cpuctl_ioctl,
  86         .d_name =       "cpuctl",
  87 };
  88
  89 /*
  90  * This function checks if specified cpu enabled or not.
  91  */
  92 static int
  93 cpu_enabled(int cpu)
  94 {
  95
  96         return (pmc_cpu_is_disabled(cpu) == 0);
  97 }
  98
  99 /*
 100  * Check if the current thread is bound to a specific cpu.
 101  */
 102 static int
 103 cpu_sched_is_bound(struct thread *td)
 104 {
 105         int ret;
 106
 107         thread_lock(td);
 108         ret = sched_is_bound(td);
 109         thread_unlock(td);
 110         return (ret);
 111 }
 112
 113 /*
 114  * Switch to target cpu to run.
 115  */
 116 static void
 117 set_cpu(int cpu, struct thread *td)
 118 {
 119
 120         KASSERT(cpu >= 0 && cpu < mp_ncpus && cpu_enabled(cpu),
 121             ("[cpuctl,%d]: bad cpu number %d", __LINE__, cpu));
 122         thread_lock(td);
 123         sched_bind(td, cpu);
 124         thread_unlock(td);
 125         KASSERT(td->td_oncpu == cpu,
 126             ("[cpuctl,%d]: cannot bind to target cpu %d", __LINE__, cpu));
 127 }
 128
 129 static void
 130 restore_cpu(int oldcpu, int is_bound, struct thread *td)
 131 {
 132
 133         KASSERT(oldcpu >= 0 && oldcpu < mp_ncpus && cpu_enabled(oldcpu),
 134             ("[cpuctl,%d]: bad cpu number %d", __LINE__, oldcpu));
 135         thread_lock(td);
 136         if (is_bound == 0)
 137                 sched_unbind(td);
 138         else
 139                 sched_bind(td, oldcpu);
 140         thread_unlock(td);
 141 }
 142
 143 int
 144 cpuctl_ioctl(struct cdev *dev, u_long cmd, caddr_t data,
 145         int flags, struct thread *td)
 146 {
 147         int ret;
 148         int cpu = minor(dev);
 149
 150         if (cpu >= mp_ncpus || !cpu_enabled(cpu)) {
 151                 DPRINTF("[cpuctl,%d]: bad cpu number %d\n", __LINE__, cpu);
 152                 return (ENXIO);
 153         }
 154         /* Require write flag for "write" requests. */
 155         if ((cmd == CPUCTL_WRMSR || cmd == CPUCTL_UPDATE) &&
 156             ((flags & FWRITE) == 0))
 157                 return (EPERM);
 158         switch (cmd) {
 159         case CPUCTL_RDMSR:
 160                 ret = cpuctl_do_msr(cpu, (cpuctl_msr_args_t *)data, cmd, td);
 161                 break;
 162         case CPUCTL_WRMSR:
 163                 ret = priv_check(td, PRIV_CPUCTL_WRMSR);
 164                 if (ret != 0)
 165                         goto fail;
 166                 ret = cpuctl_do_msr(cpu, (cpuctl_msr_args_t *)data, cmd, td);
 167                 break;
 168         case CPUCTL_CPUID:
 169                 ret = cpuctl_do_cpuid(cpu, (cpuctl_cpuid_args_t *)data, td);
 170                 break;
 171         case CPUCTL_UPDATE:
 172                 ret = priv_check(td, PRIV_CPUCTL_UPDATE);
 173                 if (ret != 0)
 174                         goto fail;
 175                 ret = cpuctl_do_update(cpu, (cpuctl_update_args_t *)data, td);
 176                 break;
 177         default:
 178                 ret = EINVAL;
 179                 break;
 180         }
 181 fail:
 182         return (ret);
 183 }
 184
 185 /*
 186  * Actually perform cpuid operation.
 187  */
 188 static int
 189 cpuctl_do_cpuid(int cpu, cpuctl_cpuid_args_t *data, struct thread *td)
 190 {
 191         int is_bound = 0;
 192         int oldcpu;
 193
 194         KASSERT(cpu >= 0 && cpu < mp_ncpus,
 195             ("[cpuctl,%d]: bad cpu number %d", __LINE__, cpu));
 196
 197         /* Explicitly clear cpuid data to avoid returning stale info. */
 198         bzero(data->data, sizeof(data->data));
 199         DPRINTF("[cpuctl,%d]: retriving cpuid level %#0x for %d cpu\n",
 200             __LINE__, data->level, cpu);
 201         oldcpu = td->td_oncpu;
 202         is_bound = cpu_sched_is_bound(td);
 203         set_cpu(cpu, td);
 204         do_cpuid(data->level, data->data);
 205         restore_cpu(oldcpu, is_bound, td);
 206         return (0);
 207 }
 208
 209 /*
 210  * Actually perform MSR operations.
 211  */
 212 static int
 213 cpuctl_do_msr(int cpu, cpuctl_msr_args_t *data, u_long cmd, struct thread *td)
 214 {
 215         int is_bound = 0;
 216         int oldcpu;
 217         int ret;
 218
 219         KASSERT(cpu >= 0 && cpu < mp_ncpus,
 220             ("[cpuctl,%d]: bad cpu number %d", __LINE__, cpu));
 221
 222         /*
 223          * Explicitly clear cpuid data to avoid returning stale
 224          * info
 225          */
 226         data->data = 0;
 227         DPRINTF("[cpuctl,%d]: operating on MSR %#0x for %d cpu\n", __LINE__,
 228             data->msr, cpu);
 229         oldcpu = td->td_oncpu;
 230         is_bound = cpu_sched_is_bound(td);
 231         set_cpu(cpu, td);
 232         ret = cmd == CPUCTL_RDMSR ? rdmsr_safe(data->msr, &data->data) :
 233             wrmsr_safe(data->msr, data->data);
 234         restore_cpu(oldcpu, is_bound, td);
 235         return (ret);
 236 }
 237
 238 /*
 239  * Actually perform microcode update.
 240  */
 241 static int
 242 cpuctl_do_update(int cpu, cpuctl_update_args_t *data, struct thread *td)
 243 {
 244         cpuctl_cpuid_args_t args = {
 245                 .level = 0,
 246         };
 247         char vendor[13];
 248         int ret;
 249
 250         KASSERT(cpu >= 0 && cpu < mp_ncpus,
 251             ("[cpuctl,%d]: bad cpu number %d", __LINE__, cpu));
 252         DPRINTF("[cpuctl,%d]: XXX %d", __LINE__, cpu);
 253
 254         ret = cpuctl_do_cpuid(cpu, &args, td);
 255         if (ret != 0) {
 256                 DPRINTF("[cpuctl,%d]: cannot retrive cpuid info for cpu %d",
 257                     __LINE__, cpu);
 258                 return (ENXIO);
 259         }
 260         ((uint32_t *)vendor)[0] = args.data[1];
 261         ((uint32_t *)vendor)[1] = args.data[3];
 262         ((uint32_t *)vendor)[2] = args.data[2];
 263         vendor[12] = '\0';
 264         if (strncmp(vendor, INTEL_VENDOR_ID, sizeof(INTEL_VENDOR_ID)) == 0)
 265                 ret = update_intel(cpu, data, td);
 266         else if(strncmp(vendor, INTEL_VENDOR_ID, sizeof(AMD_VENDOR_ID)) == 0)
 267                 ret = update_amd(cpu, data, td);
 268         else
 269                 ret = ENXIO;
 270         return (ret);
 271 }
 272
 273 static int
 274 update_intel(int cpu, cpuctl_update_args_t *args, struct thread *td)
 275 {
 276         void *ptr = NULL;
 277         uint64_t rev0, rev1;
 278         uint32_t tmp[4];
 279         int is_bound = 0;
 280         int oldcpu;
 281         int ret;
 282
 283         if (args->size == 0 || args->data == NULL) {
 284                 DPRINTF("[cpuctl,%d]: zero-sized firmware image", __LINE__);
 285                 return (EINVAL);
 286         }
 287         if (args->size > UCODE_SIZE_MAX) {
 288                 DPRINTF("[cpuctl,%d]: firmware image too large", __LINE__);
 289                 return (EINVAL);
 290         }
 291
 292         /*
 293          * 16 byte alignment required.
 294          */
 295         ptr = malloc(args->size + 16, M_CPUCTL, M_WAITOK);
 296         ptr = (void *)(16 + ((intptr_t)ptr & ~0xf));
 297         if (copyin(args->data, ptr, args->size) != 0) {
 298                 DPRINTF("[cpuctl,%d]: copyin %p->%p of %zd bytes failed",
 299                     __LINE__, args->data, ptr, args->size);
 300                 ret = EFAULT;
 301                 goto fail;
 302         }
 303         oldcpu = td->td_oncpu;
 304         is_bound = cpu_sched_is_bound(td);
 305         set_cpu(cpu, td);
 306         critical_enter();
 307         rdmsr_safe(MSR_BIOS_SIGN, &rev0); /* Get current micorcode revision. */
 308
 309         /*
 310          * Perform update.
 311          */
 312         wrmsr_safe(MSR_BIOS_UPDT_TRIG, (uintptr_t)(ptr));
 313         wrmsr_safe(MSR_BIOS_SIGN, 0);
 314
 315         /*
 316          * Serialize instruction flow.
 317          */
 318         do_cpuid(0, tmp);
 319         critical_exit();
 320         rdmsr_safe(MSR_BIOS_SIGN, &rev1); /* Get new micorcode revision. */
 321         restore_cpu(oldcpu, is_bound, td);
 322         if (rev1 > rev0)
 323                 ret = 0;
 324         else
 325                 ret = EEXIST;
 326 fail:
 327         if (ptr != NULL)
 328                 contigfree(ptr, args->size, M_CPUCTL);
 329         return (ret);
 330 }
 331
 332 static int
 333 update_amd(int cpu, cpuctl_update_args_t *args, struct thread *td)
 334 {
 335         void *ptr = NULL;
 336         uint32_t tmp[4];
 337         int is_bound = 0;
 338         int oldcpu;
 339         int ret;
 340
 341         if (args->size == 0 || args->data == NULL) {
 342                 DPRINTF("[cpuctl,%d]: zero-sized firmware image", __LINE__);
 343                 return (EINVAL);
 344         }
 345         if (args->size > UCODE_SIZE_MAX) {
 346                 DPRINTF("[cpuctl,%d]: firmware image too large", __LINE__);
 347                 return (EINVAL);
 348         }
 349         /*
 350          * XXX Might not require contignous address space - needs check
 351          */
 352         ptr = contigmalloc(args->size, M_CPUCTL, 0, 0, 0xffffffff, 16, 0);
 353         if (ptr == NULL) {
 354                 DPRINTF("[cpuctl,%d]: cannot allocate %zd bytes of memory",
 355                     __LINE__, args->size);
 356                 return (ENOMEM);
 357         }
 358         if (copyin(args->data, ptr, args->size) != 0) {
 359                 DPRINTF("[cpuctl,%d]: copyin %p->%p of %zd bytes failed",
 360                     __LINE__, args->data, ptr, args->size);
 361                 ret = EFAULT;
 362                 goto fail;
 363         }
 364         oldcpu = td->td_oncpu;
 365         is_bound = cpu_sched_is_bound(td);
 366         set_cpu(cpu, td);
 367         critical_enter();
 368
 369         /*
 370          * Perform update.
 371          */
 372         wrmsr_safe(MSR_K8_UCODE_UPDATE, (uintptr_t)args->data);
 373
 374         /*
 375          * Serialize instruction flow.
 376          */
 377         do_cpuid(0, tmp);
 378         critical_exit();
 379         restore_cpu(oldcpu, is_bound, td);
 380         ret = 0;
 381 fail:
 382         if (ptr != NULL)
 383                 contigfree(ptr, args->size, M_CPUCTL);
 384         return (ret);
 385 }
 386
 387 int
 388 cpuctl_open(struct cdev *dev, int flags, int fmt __unused, struct thread *td)
 389 {
 390         int ret = 0;
 391         int cpu;
 392
 393         cpu = minor(dev);
 394         if (cpu >= mp_ncpus || !cpu_enabled(cpu)) {
 395                 DPRINTF("[cpuctl,%d]: incorrect cpu number %d\n", __LINE__,
 396                     cpu);
 397                 return (ENXIO);
 398         }
 399         if (flags & FWRITE)
 400                 ret = securelevel_gt(td->td_ucred, 0);
 401         return (ret);
 402 }
 403
 404 static int
 405 cpuctl_modevent(module_t mod __unused, int type, void *data __unused)
 406 {
 407         int cpu;
 408
 409         switch(type) {
 410         case MOD_LOAD:
 411                 if ((cpu_feature & CPUID_MSR) == 0) {
 412                         if (bootverbose)
 413                                 printf("cpuctl: not available.\n");
 414                         return (ENODEV);
 415                 }
 416                 if (bootverbose)
 417                         printf("cpuctl: access to MSR registers/cpuid info.\n");
 418                 cpuctl_devs = (struct cdev **)malloc(sizeof(void *) * mp_ncpus,
 419                     M_CPUCTL, M_WAITOK | M_ZERO);
 420                 if (cpuctl_devs == NULL) {
 421                         DPRINTF("[cpuctl,%d]: cannot allocate memory\n",
 422                             __LINE__);
 423                         return (ENOMEM);
 424                 }
 425                 for (cpu = 0; cpu < mp_ncpus; cpu++)
 426                         if (cpu_enabled(cpu))
 427                                 cpuctl_devs[cpu] = make_dev(&cpuctl_cdevsw, cpu,
 428                                     UID_ROOT, GID_KMEM, 0640, "cpuctl%d", cpu);
 429                 break;
 430         case MOD_UNLOAD:
 431                 for (cpu = 0; cpu < mp_ncpus; cpu++) {
 432                         if (cpuctl_devs[cpu] != NULL)
 433                                 destroy_dev(cpuctl_devs[cpu]);
 434                 }
 435                 free(cpuctl_devs, M_CPUCTL);
 436                 break;
 437         case MOD_SHUTDOWN:
 438                 break;
 439         default:
 440                 return (EOPNOTSUPP);
 441         }
 442         return (0);
 443 }
 444
 445 DEV_MODULE(cpuctl, cpuctl_modevent, NULL);
 446 MODULE_VERSION(cpuctl, CPUCTL_VERSION);