bsd/kern/bsd_stubs.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22 #include <sys/time.h>
  23 #include <kern/task.h>
  24 #include <kern/thread.h>
  25 #include <mach/mach_types.h>
  26 #include <mach/vm_prot.h>
  27 #include <vm/vm_kern.h>
  28 #include <vm/vm_map.h>
  29 #include <sys/systm.h>
  30 #include <sys/conf.h>
  31 #include <sys/buf.h>    /* for SET */
  32 #include <sys/user.h>
  33
  34 /* Just to satisfy pstat command */
  35 int     dmmin, dmmax, dmtext;
  36
  37 kmem_mb_alloc(vm_map_t  mbmap, int size)
  38 {
  39         vm_offset_t addr;
  40         if (kernel_memory_allocate(mbmap, &addr, size,
  41                 0,
  42                 KMA_NOPAGEWAIT|KMA_KOBJECT) == KERN_SUCCESS)
  43                         return(addr);
  44         else
  45                 return(0);
  46
  47 }
  48
  49 pcb_synch() {}
  50
  51 struct proc *
  52 current_proc(void)
  53 {
  54         /* Never returns a NULL */
  55         struct uthread * ut;
  56         struct proc *p;
  57         thread_act_t thr_act = current_act();
  58
  59         ut = (struct uthread *)get_bsdthread_info(thr_act);
  60         if (ut &&  (ut->uu_flag & P_VFORK) && ut->uu_proc) {
  61                 p = ut->uu_proc;
  62                 if ((p->p_flag & P_INVFORK) == 0)
  63                         panic("returning child proc not under vfork");
  64                 if (p->p_vforkact != (void *)thr_act)
  65                         panic("returning child proc which is not cur_act");
  66                 return(p);
  67         }
  68
  69         p = (struct proc *)get_bsdtask_info(current_task());
  70
  71         if (p == NULL)
  72                 return (kernproc);
  73
  74         return (p);
  75 }
  76
  77 /* Device switch add delete routines */
  78
  79 extern int nblkdev, nchrdev;
  80
  81 struct bdevsw nobdev = NO_BDEVICE;
  82 struct cdevsw nocdev = NO_CDEVICE;
  83 /*
  84  *      if index is -1, return a free slot if avaliable
  85  *        else see whether the index is free
  86  *      return the major number that is free else -1
  87  *
  88  */
  89 int
  90 bdevsw_isfree(int index)
  91 {
  92         struct bdevsw *devsw;
  93         if (index == -1) {
  94             devsw = bdevsw;
  95             for(index=0; index < nblkdev; index++, devsw++) {
  96                 if(memcmp((char *)devsw,
  97                             (char *)&nobdev,
  98                             sizeof(struct bdevsw)) == 0)
  99                     break;
 100             }
 101         } else {
 102                 /* NB: Not used below unless index is in range */
 103                 devsw = &bdevsw[index];
 104         }
 105
 106         if ((index < 0) || (index >= nblkdev) ||
 107             (memcmp((char *)devsw,
 108                           (char *)&nobdev,
 109                           sizeof(struct bdevsw)) != 0)) {
 110                 return(-1);
 111         }
 112         return(index);
 113 }
 114
 115 /*
 116  *      if index is -1, find a free slot to add
 117  *        else see whether the slot is free
 118  *      return the major number that is used else -1
 119  */
 120 int
 121 bdevsw_add(int index, struct bdevsw * bsw)
 122 {
 123         struct bdevsw *devsw;
 124
 125         if (index == -1) {
 126             devsw = &bdevsw[1];         /* Start at slot 1 - this is a hack to fix the index=1 hack */
 127             /* yes, start at 1 to avoid collision with volfs (Radar 2842228) */
 128             for(index=1; index < nblkdev; index++, devsw++) {
 129                 if(memcmp((char *)devsw,
 130                             (char *)&nobdev,
 131                             sizeof(struct bdevsw)) == 0)
 132                     break;
 133             }
 134         }
 135         devsw = &bdevsw[index];
 136         if ((index < 0) || (index >= nblkdev) ||
 137             (memcmp((char *)devsw,
 138                           (char *)&nobdev,
 139                           sizeof(struct bdevsw)) != 0)) {
 140                 return(-1);
 141         }
 142         bdevsw[index] = *bsw;
 143         return(index);
 144 }
 145 /*
 146  *      if the slot has the same bsw, then remove
 147  *      else -1
 148  */
 149 int
 150 bdevsw_remove(int index, struct bdevsw * bsw)
 151 {
 152         struct bdevsw *devsw;
 153
 154         devsw = &bdevsw[index];
 155         if ((index < 0) || (index >= nblkdev) ||
 156             (memcmp((char *)devsw,
 157                           (char *)bsw,
 158                           sizeof(struct bdevsw)) != 0)) {
 159                 return(-1);
 160         }
 161         bdevsw[index] = nobdev;
 162         return(index);
 163 }
 164
 165 /*
 166  *      if index is -1, return a free slot if avaliable
 167  *        else see whether the index is free
 168  *      return the major number that is free else -1
 169  */
 170 int
 171 cdevsw_isfree(int index)
 172 {
 173         struct cdevsw *devsw;
 174
 175         if (index == -1) {
 176             devsw = cdevsw;
 177             for(index=0; index < nchrdev; index++, devsw++) {
 178                 if(memcmp((char *)devsw,
 179                             (char *)&nocdev,
 180                             sizeof(struct cdevsw)) == 0)
 181                     break;
 182             }
 183         }
 184         devsw = &cdevsw[index];
 185         if ((index < 0) || (index >= nchrdev) ||
 186             (memcmp((char *)devsw,
 187                           (char *)&nocdev,
 188                           sizeof(struct cdevsw)) != 0)) {
 189                 return(-1);
 190         }
 191         return(index);
 192 }
 193
 194 /*
 195  *      if index is -1, find a free slot to add
 196  *        else see whether the slot is free
 197  *      return the major number that is used else -1
 198  */
 199 int
 200 cdevsw_add(int index, struct cdevsw * csw)
 201 {
 202         struct cdevsw *devsw;
 203
 204         if (index == -1) {
 205             devsw = cdevsw;
 206             for(index=0; index < nchrdev; index++, devsw++) {
 207                 if(memcmp((char *)devsw,
 208                             (char *)&nocdev,
 209                             sizeof(struct cdevsw)) == 0)
 210                     break;
 211             }
 212         }
 213         devsw = &cdevsw[index];
 214         if ((index < 0) || (index >= nchrdev) ||
 215             (memcmp((char *)devsw,
 216                           (char *)&nocdev,
 217                           sizeof(struct cdevsw)) != 0)) {
 218                 return(-1);
 219         }
 220         cdevsw[index] = *csw;
 221         return(index);
 222 }
 223 /*
 224  *      if the index has the same bsw, then remove
 225  *      else -1
 226  */
 227 int
 228 cdevsw_remove(int index, struct cdevsw * csw)
 229 {
 230         struct cdevsw *devsw;
 231
 232         devsw = &cdevsw[index];
 233         if ((index < 0) || (index >= nchrdev) ||
 234             (memcmp((char *)devsw,
 235                           (char *)csw,
 236                           sizeof(struct cdevsw)) != 0)) {
 237                 return(-1);
 238         }
 239         cdevsw[index] = nocdev;
 240         return(index);
 241 }
 242
 243 static int
 244 cdev_set_bdev(int cdev, int bdev)
 245 {
 246         extern int chrtoblk_add(int cdev, int bdev);
 247
 248         return (chrtoblk_set(cdev, bdev));
 249 }
 250
 251 int
 252 cdevsw_add_with_bdev(int index, struct cdevsw * csw, int bdev)
 253 {
 254         index = cdevsw_add(index, csw);
 255         if (index < 0) {
 256                 return (index);
 257         }
 258         if (cdev_set_bdev(index, bdev) < 0) {
 259                 cdevsw_remove(index, csw);
 260                 return (-1);
 261         }
 262         return (index);
 263 }
 264
 265 issingleuser(void)
 266 {
 267         char namep[16];
 268
 269
 270         if (PE_parse_boot_arg("-s", namep)) {
 271                 return(1);
 272         } else {
 273                 return(0);
 274         }
 275 }
 276
 277 void *
 278 tbeproc(void *procp)
 279 {
 280         struct proc *p = procp;
 281
 282         if (p)
 283                 SET(p->p_flag, P_TBE);
 284         return;
 285 }
 286