bsd/pgo/profile_runtime.c

   1 /*
   2  * Copyright (c) 2014 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #include <sys/sysproto.h>
  30 #include <sys/malloc.h>
  31 #include <sys/systm.h>
  32 #include <sys/pgo.h>
  33 #include <sys/kauth.h>
  34 #include <security/mac_framework.h>
  35 #include <libkern/OSKextLib.h>
  36
  37
  38 /*
  39  * This tells compiler_rt not to include userspace-specific stuff writing
  40  * profile data to a file.
  41  */
  42 int __llvm_profile_runtime = 0;
  43
  44
  45 #ifdef PROFILE
  46
  47 /* These __llvm functions are defined in InstrProfiling.h in compiler_rt.  That
  48  * is a internal header, so we need to re-prototype them here.  */
  49
  50 uint64_t __llvm_profile_get_size_for_buffer(void);
  51 int __llvm_profile_write_buffer(char *Buffer);
  52 uint64_t __llvm_profile_get_size_for_buffer_internal(const char *DataBegin,
  53                                                      const char *DataEnd,
  54                                                      const char *CountersBegin,
  55                                                      const char *CountersEnd ,
  56                                                      const char *NamesBegin,
  57                                                      const char *NamesEnd);
  58 int __llvm_profile_write_buffer_internal(char *Buffer,
  59                                          const char *DataBegin,
  60                                          const char *DataEnd,
  61                                          const char *CountersBegin,
  62                                          const char *CountersEnd ,
  63                                          const char *NamesBegin,
  64                                          const char *NamesEnd);
  65
  66 extern char __pgo_hib_DataStart __asm("section$start$__HIB$__llvm_prf_data");
  67 extern char __pgo_hib_DataEnd   __asm("section$end$__HIB$__llvm_prf_data");
  68 extern char __pgo_hib_NamesStart __asm("section$start$__HIB$__llvm_prf_names");
  69 extern char __pgo_hib_NamesEnd   __asm("section$end$__HIB$__llvm_prf_names");
  70 extern char __pgo_hib_CountersStart __asm("section$start$__HIB$__llvm_prf_cnts");
  71 extern char __pgo_hib_CountersEnd   __asm("section$end$__HIB$__llvm_prf_cnts");
  72
  73
  74 static uint64_t get_size_for_buffer(int flags)
  75 {
  76         if (flags & PGO_HIB) {
  77                 return __llvm_profile_get_size_for_buffer_internal(
  78                         &__pgo_hib_DataStart, &__pgo_hib_DataEnd,
  79                         &__pgo_hib_CountersStart, &__pgo_hib_CountersEnd,
  80                         &__pgo_hib_NamesStart, &__pgo_hib_NamesEnd);
  81         } else {
  82                 return __llvm_profile_get_size_for_buffer();
  83         }
  84 }
  85
  86
  87 static int write_buffer(int flags, char *buffer)
  88 {
  89         if (flags & PGO_HIB) {
  90                 return __llvm_profile_write_buffer_internal(
  91                         buffer,
  92                         &__pgo_hib_DataStart, &__pgo_hib_DataEnd,
  93                         &__pgo_hib_CountersStart, &__pgo_hib_CountersEnd,
  94                         &__pgo_hib_NamesStart, &__pgo_hib_NamesEnd);
  95         } else {
  96                 return __llvm_profile_write_buffer(buffer);
  97         }
  98 }
  99
 100
 101 #endif
 102
 103
 104
 105 /*
 106  * returns:
 107  *   EPERM  unless you are root
 108  *   EINVAL for invalid args.
 109  *   ENOSYS for not implemented
 110  *   ERANGE for integer overflow
 111  *   ENOENT if kext not found
 112  *   ENOTSUP kext does not support PGO
 113  *   EIO llvm returned an error.  shouldn't ever happen.
 114  */
 115
 116 int grab_pgo_data(struct proc *p,
 117                   struct grab_pgo_data_args *uap,
 118                   register_t *retval)
 119 {
 120         char *buffer = NULL;
 121         int err = 0;
 122
 123         (void) p;
 124
 125         if (!kauth_cred_issuser(kauth_cred_get())) {
 126                 err = EPERM;
 127                 goto out;
 128         }
 129
 130 #if CONFIG_MACF
 131         err = mac_system_check_info(kauth_cred_get(), "kern.profiling_data");
 132         if (err) {
 133                 goto out;
 134         }
 135 #endif
 136
 137         if ( uap->flags & ~PGO_ALL_FLAGS ||
 138              uap->size < 0 ||
 139              (uap->size > 0 && uap->buffer == 0))
 140         {
 141                 err = EINVAL;
 142                 goto out;
 143         }
 144
 145         *retval = 0;
 146
 147         if (uap->uuid) {
 148                 uuid_t uuid;
 149                 err = copyin(uap->uuid, &uuid, sizeof(uuid));
 150                 if (err) {
 151                         goto out;
 152                 }
 153
 154                 if (uap->buffer == 0 && uap->size == 0) {
 155                     uint64_t size64;
 156
 157                     if (uap->flags & PGO_WAIT_FOR_UNLOAD) {
 158                         err = EINVAL;
 159                         goto out;
 160                     }
 161
 162                     err = OSKextGrabPgoData(uuid, &size64, NULL, 0, 0, !!(uap->flags & PGO_METADATA));
 163                     if (err) {
 164                         goto out;
 165                     }
 166
 167                     ssize_t size = size64;
 168                     if ( ((uint64_t) size) != size64  ||
 169                          size < 0 )
 170                     {
 171                         err = ERANGE;
 172                         goto out;
 173                     }
 174
 175                     *retval = size;
 176                     err = 0;
 177                     goto out;
 178
 179                 } else if (!uap->buffer || uap->size <= 0) {
 180
 181                     err = EINVAL;
 182                     goto out;
 183
 184                 } else {
 185
 186                     MALLOC(buffer, char *, uap->size, M_TEMP, M_WAITOK);
 187                     if (!buffer) {
 188                         err = ENOMEM;
 189                         goto out;
 190                     }
 191
 192                     uint64_t size64;
 193
 194                     err = OSKextGrabPgoData(uuid, &size64, buffer, uap->size,
 195                                             !!(uap->flags & PGO_WAIT_FOR_UNLOAD),
 196                                             !!(uap->flags & PGO_METADATA));
 197                     if (err) {
 198                         goto out;
 199                     }
 200
 201                     ssize_t size = size64;
 202                     if ( ((uint64_t) size) != size64  ||
 203                          size < 0 )
 204                     {
 205                         err = ERANGE;
 206                         goto out;
 207                     }
 208
 209                     err = copyout(buffer, uap->buffer, size);
 210                     if (err) {
 211                         goto out;
 212                     }
 213
 214                     *retval = size;
 215                     goto out;
 216                 }
 217         }
 218
 219
 220 #ifdef PROFILE
 221
 222         uint64_t size64 = get_size_for_buffer(uap->flags);
 223         ssize_t size = size64;
 224
 225         if (uap->flags & (PGO_WAIT_FOR_UNLOAD | PGO_METADATA)) {
 226             err = EINVAL;
 227             goto out;
 228         }
 229
 230         if ( ((uint64_t) size) != size64  ||
 231              size < 0 )
 232         {
 233                 err = ERANGE;
 234                 goto out;
 235         }
 236
 237
 238         if (uap->buffer == 0 && uap->size == 0) {
 239                 *retval = size;
 240                 err = 0;
 241                 goto out;
 242         } else if (uap->size < size) {
 243                 err = EINVAL;
 244                 goto out;
 245         } else {
 246                 MALLOC(buffer, char *, size, M_TEMP, M_WAITOK);
 247                 if (!buffer) {
 248                         err = ENOMEM;
 249                         goto out;
 250                 }
 251
 252                 err = write_buffer(uap->flags, buffer);
 253                 if (err)
 254                 {
 255                     err = EIO;
 256                     goto out;
 257                 }
 258
 259                 err = copyout(buffer, uap->buffer, size);
 260                 if (err) {
 261                         goto out;
 262                 }
 263
 264                 *retval = size;
 265                 goto out;
 266         }
 267
 268 #else
 269
 270         *retval = -1;
 271         err = ENOSYS;
 272         goto out;
 273
 274 #endif
 275
 276 out:
 277         if (buffer) {
 278                 FREE(buffer, M_TEMP);
 279         }
 280         if (err) {
 281                 *retval = -1;
 282         }
 283         return err;
 284 }