bsd/kern/bsd_stubs.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, 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 #include <sys/time.h>
  29 #include <kern/task.h>
  30 #include <kern/thread.h>
  31 #include <mach/mach_types.h>
  32 #include <mach/vm_prot.h>
  33 #include <vm/vm_kern.h>
  34 #include <sys/stat.h>
  35 #include <vm/vm_map.h>
  36 #include <sys/systm.h>
  37 #include <kern/assert.h>
  38 #include <sys/conf.h>
  39 #include <sys/proc_internal.h>
  40 #include <sys/buf.h> /* for SET */
  41 #include <sys/kernel.h>
  42 #include <sys/user.h>
  43 #include <sys/sysent.h>
  44 #include <sys/sysproto.h>
  45
  46 /* XXX these should be in a common header somwhere, but aren't */
  47 extern int chrtoblk_set(int, int);
  48 extern vm_offset_t kmem_mb_alloc(vm_map_t, int, int);
  49
  50 /* XXX most of these just exist to export; there's no good header for them*/
  51 void pcb_synch(void);
  52
  53 TAILQ_HEAD(, devsw_lock) devsw_locks;
  54 lck_mtx_t devsw_lock_list_mtx;
  55 lck_grp_t * devsw_lock_grp;
  56
  57 /* Just to satisfy pstat command */
  58 int dmmin, dmmax, dmtext;
  59
  60 vm_offset_t
  61 kmem_mb_alloc(vm_map_t mbmap, int size, int physContig)
  62 {
  63         vm_offset_t addr = 0;
  64         kern_return_t kr = KERN_SUCCESS;
  65
  66         if (!physContig)
  67                 kr = kernel_memory_allocate(mbmap, &addr, size, 0, KMA_NOPAGEWAIT | KMA_KOBJECT | KMA_LOMEM, VM_KERN_MEMORY_MBUF);
  68         else
  69                 kr = kmem_alloc_contig(mbmap, &addr, size, PAGE_MASK, 0xfffff, 0, KMA_NOPAGEWAIT | KMA_KOBJECT | KMA_LOMEM, VM_KERN_MEMORY_MBUF);
  70
  71         if (kr != KERN_SUCCESS)
  72                 addr = 0;
  73
  74         return addr;
  75 }
  76
  77 /*
  78  * XXX this function only exists to be exported and do nothing.
  79  */
  80 void
  81 pcb_synch(void)
  82 {
  83 }
  84
  85 struct proc *
  86 current_proc(void)
  87 {
  88         /* Never returns a NULL */
  89         struct uthread * ut;
  90         struct proc * p;
  91         thread_t thread = current_thread();
  92
  93         ut = (struct uthread *)get_bsdthread_info(thread);
  94         if (ut && (ut->uu_flag & UT_VFORK) && ut->uu_proc) {
  95                 p = ut->uu_proc;
  96                 if ((p->p_lflag & P_LINVFORK) == 0)
  97                         panic("returning child proc not under vfork");
  98                 if (p->p_vforkact != (void *)thread)
  99                         panic("returning child proc which is not cur_act");
 100                 return (p);
 101         }
 102
 103         p = (struct proc *)get_bsdtask_info(current_task());
 104
 105         if (p == NULL)
 106                 return (kernproc);
 107
 108         return (p);
 109 }
 110
 111 /* Device switch add delete routines */
 112
 113 struct bdevsw nobdev = NO_BDEVICE;
 114 struct cdevsw nocdev = NO_CDEVICE;
 115 /*
 116  *      if index is -1, return a free slot if avaliable
 117  *        else see whether the index is free
 118  *      return the major number that is free else -1
 119  *
 120  *      if index is negative, we start
 121  *      looking for a free slot at the absolute value of index,
 122  *      instead of starting at 0
 123  */
 124 int
 125 bdevsw_isfree(int index)
 126 {
 127         struct bdevsw * devsw;
 128
 129         if (index < 0) {
 130                 if (index == -1)
 131                         index = 1; /* start at 1 to avoid collision with volfs (Radar 2842228) */
 132                 else
 133                         index = -index; /* start at least this far up in the table */
 134                 devsw = &bdevsw[index];
 135                 for (; index < nblkdev; index++, devsw++) {
 136                         if (memcmp((char *)devsw, (char *)&nobdev, sizeof(struct bdevsw)) == 0)
 137                                 break;
 138                 }
 139         }
 140
 141         if (index < 0 || index >= nblkdev)
 142                 return (-1);
 143
 144         devsw = &bdevsw[index];
 145         if ((memcmp((char *)devsw, (char *)&nobdev, sizeof(struct bdevsw)) != 0)) {
 146                 return (-1);
 147         }
 148         return (index);
 149 }
 150
 151 /*
 152  *      if index is -1, find a free slot to add
 153  *        else see whether the slot is free
 154  *      return the major number that is used else -1
 155  *
 156  *      if index is negative, we start
 157  *      looking for a free slot at the absolute value of index,
 158  *      instead of starting at 0
 159  */
 160 int
 161 bdevsw_add(int index, struct bdevsw * bsw)
 162 {
 163         lck_mtx_lock_spin(&devsw_lock_list_mtx);
 164         index = bdevsw_isfree(index);
 165         if (index < 0) {
 166                 index = -1;
 167         } else {
 168                 bdevsw[index] = *bsw;
 169         }
 170         lck_mtx_unlock(&devsw_lock_list_mtx);
 171         return (index);
 172 }
 173 /*
 174  *      if the slot has the same bsw, then remove
 175  *      else -1
 176  */
 177 int
 178 bdevsw_remove(int index, struct bdevsw * bsw)
 179 {
 180         struct bdevsw * devsw;
 181
 182         if (index < 0 || index >= nblkdev)
 183                 return (-1);
 184
 185         devsw = &bdevsw[index];
 186         lck_mtx_lock_spin(&devsw_lock_list_mtx);
 187         if ((memcmp((char *)devsw, (char *)bsw, sizeof(struct bdevsw)) != 0)) {
 188                 index = -1;
 189         } else {
 190                 bdevsw[index] = nobdev;
 191         }
 192         lck_mtx_unlock(&devsw_lock_list_mtx);
 193         return (index);
 194 }
 195
 196 /*
 197  *      if index is -1, return a free slot if avaliable
 198  *        else see whether the index is free
 199  *      return the major number that is free else -1
 200  *
 201  *      if index is negative, we start
 202  *      looking for a free slot at the absolute value of index,
 203  *      instead of starting at 0
 204  */
 205 int
 206 cdevsw_isfree(int index)
 207 {
 208         struct cdevsw * devsw;
 209
 210         if (index < 0) {
 211                 if (index == -1)
 212                         index = 0;
 213                 else
 214                         index = -index; /* start at least this far up in the table */
 215                 devsw = &cdevsw[index];
 216                 for (; index < nchrdev; index++, devsw++) {
 217                         if (memcmp((char *)devsw, (char *)&nocdev, sizeof(struct cdevsw)) == 0)
 218                                 break;
 219                 }
 220         }
 221
 222         if (index < 0 || index >= nchrdev)
 223                 return (-1);
 224
 225         devsw = &cdevsw[index];
 226         if ((memcmp((char *)devsw, (char *)&nocdev, sizeof(struct cdevsw)) != 0)) {
 227                 return (-1);
 228         }
 229         return (index);
 230 }
 231
 232 /*
 233  *      if index is -1, find a free slot to add
 234  *        else see whether the slot is free
 235  *      return the major number that is used else -1
 236  *
 237  *      if index is negative, we start
 238  *      looking for a free slot at the absolute value of index,
 239  *      instead of starting at 0
 240  *
 241  * NOTE:        In practice, -1 is unusable, since there are kernel internal
 242  *              devices that call this function with absolute index values,
 243  *              which will stomp on free-slot based assignments that happen
 244  *              before them.  -24 is currently a safe starting point.
 245  */
 246 int
 247 cdevsw_add(int index, struct cdevsw * csw)
 248 {
 249         lck_mtx_lock_spin(&devsw_lock_list_mtx);
 250         index = cdevsw_isfree(index);
 251         if (index < 0) {
 252                 index = -1;
 253         } else {
 254                 cdevsw[index] = *csw;
 255         }
 256         lck_mtx_unlock(&devsw_lock_list_mtx);
 257         return (index);
 258 }
 259 /*
 260  *      if the slot has the same csw, then remove
 261  *      else -1
 262  */
 263 int
 264 cdevsw_remove(int index, struct cdevsw * csw)
 265 {
 266         struct cdevsw * devsw;
 267
 268         if (index < 0 || index >= nchrdev)
 269                 return (-1);
 270
 271         devsw = &cdevsw[index];
 272         lck_mtx_lock_spin(&devsw_lock_list_mtx);
 273         if ((memcmp((char *)devsw, (char *)csw, sizeof(struct cdevsw)) != 0)) {
 274                 index = -1;
 275         } else {
 276                 cdevsw[index] = nocdev;
 277                 cdevsw_flags[index] = 0;
 278         }
 279         lck_mtx_unlock(&devsw_lock_list_mtx);
 280         return (index);
 281 }
 282
 283 static int
 284 cdev_set_bdev(int cdev, int bdev)
 285 {
 286         return (chrtoblk_set(cdev, bdev));
 287 }
 288
 289 int
 290 cdevsw_add_with_bdev(int index, struct cdevsw * csw, int bdev)
 291 {
 292         index = cdevsw_add(index, csw);
 293         if (index < 0) {
 294                 return (index);
 295         }
 296         if (cdev_set_bdev(index, bdev) < 0) {
 297                 cdevsw_remove(index, csw);
 298                 return (-1);
 299         }
 300         return (index);
 301 }
 302
 303 int
 304 cdevsw_setkqueueok(int maj, struct cdevsw * csw, int extra_flags)
 305 {
 306         struct cdevsw * devsw;
 307         uint64_t flags = CDEVSW_SELECT_KQUEUE;
 308
 309         if (maj < 0 || maj >= nchrdev) {
 310                 return -1;
 311         }
 312
 313         devsw = &cdevsw[maj];
 314         if ((memcmp((char *)devsw, (char *)csw, sizeof(struct cdevsw)) != 0)) {
 315                 return -1;
 316         }
 317
 318         flags |= extra_flags;
 319
 320         cdevsw_flags[maj] = flags;
 321         return 0;
 322 }
 323
 324 #include <pexpert/pexpert.h> /* for PE_parse_boot_arg */
 325
 326 /*
 327  * Copy the "hostname" variable into a caller-provided buffer
 328  * Returns: 0 for success, ENAMETOOLONG for insufficient buffer space.
 329  * On success, "len" will be set to the number of characters preceding
 330  * the NULL character in the hostname.
 331  */
 332 int
 333 bsd_hostname(char * buf, int bufsize, int * len)
 334 {
 335         /*
 336          * "hostname" is null-terminated, and "hostnamelen" is equivalent to strlen(hostname).
 337          */
 338         if (hostnamelen < bufsize) {
 339                 strlcpy(buf, hostname, bufsize);
 340                 *len = hostnamelen;
 341                 return 0;
 342         } else {
 343                 return ENAMETOOLONG;
 344         }
 345 }
 346
 347 void
 348 devsw_lock(dev_t dev, int mode)
 349 {
 350         devsw_lock_t newlock, tmplock;
 351         int res;
 352
 353         assert(0 <= major(dev) && major(dev) < nchrdev);
 354         assert(mode == S_IFCHR || mode == S_IFBLK);
 355
 356         MALLOC(newlock, devsw_lock_t, sizeof(struct devsw_lock), M_TEMP, M_WAITOK | M_ZERO);
 357         newlock->dl_dev = dev;
 358         newlock->dl_thread = current_thread();
 359         newlock->dl_mode = mode;
 360
 361         lck_mtx_lock_spin(&devsw_lock_list_mtx);
 362 retry:
 363         TAILQ_FOREACH(tmplock, &devsw_locks, dl_list)
 364         {
 365                 if (tmplock->dl_dev == dev && tmplock->dl_mode == mode) {
 366                         res = msleep(tmplock, &devsw_lock_list_mtx, PVFS, "devsw_lock", NULL);
 367                         assert(res == 0);
 368                         goto retry;
 369                 }
 370         }
 371
 372         TAILQ_INSERT_TAIL(&devsw_locks, newlock, dl_list);
 373         lck_mtx_unlock(&devsw_lock_list_mtx);
 374 }
 375 void
 376 devsw_unlock(dev_t dev, int mode)
 377 {
 378         devsw_lock_t tmplock;
 379
 380         assert(0 <= major(dev) && major(dev) < nchrdev);
 381
 382         lck_mtx_lock_spin(&devsw_lock_list_mtx);
 383
 384         TAILQ_FOREACH(tmplock, &devsw_locks, dl_list)
 385         {
 386                 if (tmplock->dl_dev == dev && tmplock->dl_mode == mode) {
 387                         break;
 388                 }
 389         }
 390
 391         if (tmplock == NULL) {
 392                 panic("Trying to unlock, and couldn't find lock.");
 393         }
 394
 395         if (tmplock->dl_thread != current_thread()) {
 396                 panic("Trying to unlock, but I don't hold the lock.");
 397         }
 398
 399         wakeup(tmplock);
 400         TAILQ_REMOVE(&devsw_locks, tmplock, dl_list);
 401
 402         lck_mtx_unlock(&devsw_lock_list_mtx);
 403
 404         FREE(tmplock, M_TEMP);
 405 }
 406
 407 void
 408 devsw_init()
 409 {
 410         devsw_lock_grp = lck_grp_alloc_init("devsw", NULL);
 411         assert(devsw_lock_grp != NULL);
 412
 413         lck_mtx_init(&devsw_lock_list_mtx, devsw_lock_grp, NULL);
 414         TAILQ_INIT(&devsw_locks);
 415 }