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