X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/ff6e181ae92fc6f1e89841290f461d1f2f9badd9..13f56ec4e58bf8687e2a68032c093c0213dd519b:/bsd/kern/bsd_stubs.c

diff --git a/bsd/kern/bsd_stubs.c b/bsd/kern/bsd_stubs.c
index d3657cb8b..19da61270 100644
--- a/bsd/kern/bsd_stubs.c
+++ b/bsd/kern/bsd_stubs.c
@@ -1,14 +1,19 @@
 /*
  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
  *
- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ * 
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
  * 
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
@@ -18,7 +23,7 @@
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * 
- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 #include <sys/time.h>
 #include <kern/task.h>
@@ -26,27 +31,50 @@
 #include <mach/mach_types.h>
 #include <mach/vm_prot.h>
 #include <vm/vm_kern.h>
+#include <sys/stat.h>
 #include <vm/vm_map.h>
 #include <sys/systm.h>
+#include <kern/assert.h>
 #include <sys/conf.h>
 #include <sys/proc_internal.h>
 #include <sys/buf.h>	/* for SET */
+#include <sys/kernel.h>
 #include <sys/user.h>
+#include <sys/sysent.h>
+#include <sys/sysproto.h>
+
+/* XXX these should be in a common header somwhere, but aren't */
+extern int chrtoblk_set(int, int);
+extern vm_offset_t kmem_mb_alloc(vm_map_t, int, int);
+
+/* XXX most of these just exist to export; there's no good header for them*/
+void	pcb_synch(void);
+void	tbeproc(void *);
+
+TAILQ_HEAD(,devsw_lock) devsw_locks;
+lck_mtx_t devsw_lock_list_mtx;
+lck_grp_t *devsw_lock_grp;
 
 /* Just to satisfy pstat command */
 int     dmmin, dmmax, dmtext;
 
 vm_offset_t
-kmem_mb_alloc(vm_map_t  mbmap, int size) 
+kmem_mb_alloc(vm_map_t  mbmap, int size, int physContig) 
 {
-        vm_offset_t addr;
-	if (kernel_memory_allocate(mbmap, &addr, size,
-   		0,
-		KMA_NOPAGEWAIT|KMA_KOBJECT) == KERN_SUCCESS)
-   			return(addr);
+        vm_offset_t addr = 0;
+	kern_return_t kr = KERN_SUCCESS;
+
+	if(!physContig)
+		kr = kernel_memory_allocate(mbmap, &addr, size,
+			0, KMA_NOPAGEWAIT|KMA_KOBJECT|KMA_LOMEM);
 	else
-		return(0);
-		
+		kr = kmem_alloc_contig(mbmap, &addr, size, PAGE_MASK, 
+			0xfffff, 0, KMA_NOPAGEWAIT | KMA_KOBJECT | KMA_LOMEM);
+
+	if( kr != KERN_SUCCESS)
+		addr = 0;
+
+	return addr;
 }
 
 /*
@@ -63,14 +91,14 @@ current_proc(void)
 	/* Never returns a NULL */
 	struct uthread * ut;
 	struct proc *p; 
-	thread_t thr_act = current_thread();
+	thread_t thread = current_thread();
 
-	ut = (struct uthread *)get_bsdthread_info(thr_act); 
+	ut = (struct uthread *)get_bsdthread_info(thread); 
 	if (ut &&  (ut->uu_flag & UT_VFORK) && ut->uu_proc) {
 		p = ut->uu_proc;
-		if ((p->p_flag & P_INVFORK) == 0) 
+		if ((p->p_lflag & P_LINVFORK) == 0) 
 			panic("returning child proc not under vfork");
-		if (p->p_vforkact != (void *)thr_act) 
+		if (p->p_vforkact != (void *)thread) 
 			panic("returning child proc which is not cur_act");
 		return(p);
 	}
@@ -85,8 +113,6 @@ current_proc(void)
 
 /* Device switch add delete routines */
 
-extern int nblkdev, nchrdev;
-
 struct bdevsw nobdev = NO_BDEVICE;
 struct cdevsw nocdev = NO_CDEVICE;
 /* 
@@ -204,15 +230,28 @@ cdevsw_isfree(int index)
  *	if index is -1, find a free slot to add
  *	  else see whether the slot is free
  *	return the major number that is used else -1
+ *
+ * NOTE:	In practice, -1 is unusable, since there are kernel internal
+ *		devices that call this function with absolute index values,
+ *		which will stomp on free-slot based assignments that happen
+ *		before them.  Therefore, if index is negative, we start
+ *		looking for a free slot at the absolute value of index,
+ *		instead of starting at 0 (lets out slot 1, but that's one
+ *		of the problem slots down low - the vndevice).  -12 is
+ *		currently a safe starting point.
  */
 int
 cdevsw_add(int index, struct cdevsw * csw) 
 {
 	struct cdevsw *devsw;
 
-	if (index == -1) {
-	    devsw = cdevsw;
-	    for(index=0; index < nchrdev; index++, devsw++) {
+	if (index < 0) {
+	    if (index == -1)
+	    	index = 0;	/* historical behaviour; XXX broken */
+	    else
+	        index = -index;	/* start at least this far up in the table */
+	    devsw = &cdevsw[index];
+	    for(; index < nchrdev; index++, devsw++) {
 		if(memcmp((char *)devsw, 
 			    (char *)&nocdev, 
 			    sizeof(struct cdevsw)) == 0)
@@ -246,14 +285,13 @@ cdevsw_remove(int index, struct cdevsw * csw)
 		return(-1);
 	}
 	cdevsw[index] = nocdev;
+	cdevsw_flags[index] = 0;
 	return(index);
 }
 
 static int
 cdev_set_bdev(int cdev, int bdev)
 {
-	extern int chrtoblk_add(int cdev, int bdev);
-
 	return (chrtoblk_set(cdev, bdev));
 }
 
@@ -271,25 +309,126 @@ cdevsw_add_with_bdev(int index, struct cdevsw * csw, int bdev)
 	return (index);
 }
 
-issingleuser(void)
+int
+cdevsw_setkqueueok(int index, struct cdevsw *csw, int use_offset)
 {
-	char namep[16];
+	struct cdevsw *devsw;
+	uint64_t flags = CDEVSW_SELECT_KQUEUE;
 
+	devsw = &cdevsw[index];
+	if ((index < 0) || (index >= nchrdev) ||
+	    (memcmp((char *)devsw, 
+		          (char *)csw, 
+			  sizeof(struct cdevsw)) != 0)) {
+		return(-1);
+	}
 
-	if (PE_parse_boot_arg("-s", namep)) {
-		return(1);
-	} else {
-		return(0);
+	if (use_offset) {
+		flags |= CDEVSW_USE_OFFSET;
 	}
+
+	cdevsw_flags[index] = flags;
+	return 0;
 }
 
-void *
+#include <pexpert/pexpert.h>	/* for PE_parse_boot_arg */
+
+void
 tbeproc(void *procp)
 {
 	struct proc *p = procp;
 
 	if (p)
-		SET(p->p_flag, P_TBE);
+		OSBitOrAtomic(P_TBE, &p->p_flag);
 	return;
 }
 
+/*
+ * Copy the "hostname" variable into a caller-provided buffer
+ * Returns: 0 for success, ENAMETOOLONG for insufficient buffer space.
+ * On success, "len" will be set to the number of characters preceding 
+ * the NULL character in the hostname.
+ */
+int
+bsd_hostname(char *buf, int bufsize, int *len)
+{
+	/*
+ 	 * "hostname" is null-terminated, and "hostnamelen" is equivalent to strlen(hostname).
+	 */
+	if (hostnamelen < bufsize) {
+		strlcpy(buf, hostname, bufsize);
+		*len = hostnamelen;
+		return 0;
+	} else {
+		return ENAMETOOLONG;
+	}    
+}
+
+void
+devsw_lock(dev_t dev, int mode)
+{
+	devsw_lock_t newlock, tmplock;
+	int res;
+
+	assert(0 <= major(dev) && major(dev) < nchrdev);	
+	assert(mode == S_IFCHR || mode == S_IFBLK);
+
+	MALLOC(newlock, devsw_lock_t, sizeof(struct devsw_lock), M_TEMP, M_WAITOK | M_ZERO);
+	newlock->dl_dev = dev;
+	newlock->dl_thread = current_thread();
+	newlock->dl_mode = mode;
+	
+	lck_mtx_lock_spin(&devsw_lock_list_mtx);
+retry:
+	TAILQ_FOREACH(tmplock, &devsw_locks, dl_list) {
+		if (tmplock->dl_dev == dev && tmplock->dl_mode == mode) {
+			res = msleep(tmplock, &devsw_lock_list_mtx, PVFS, "devsw_lock", NULL);	
+			assert(res == 0);
+			goto retry;
+		}
+	}
+
+	TAILQ_INSERT_TAIL(&devsw_locks, newlock, dl_list);
+	lck_mtx_unlock(&devsw_lock_list_mtx);
+
+}
+void
+devsw_unlock(dev_t dev, int mode)
+{
+	devsw_lock_t tmplock;
+
+	assert(0 <= major(dev) && major(dev) < nchrdev);	
+
+	lck_mtx_lock_spin(&devsw_lock_list_mtx);
+
+	TAILQ_FOREACH(tmplock, &devsw_locks, dl_list) {
+		if (tmplock->dl_dev == dev && tmplock->dl_mode == mode) {	
+			break;
+		}
+	}
+
+	if (tmplock == NULL) {
+		panic("Trying to unlock, and couldn't find lock.");
+	}
+
+	if (tmplock->dl_thread != current_thread()) {
+		panic("Trying to unlock, but I don't hold the lock.");
+	}
+
+	wakeup(tmplock);
+	TAILQ_REMOVE(&devsw_locks, tmplock, dl_list);
+	
+	lck_mtx_unlock(&devsw_lock_list_mtx);
+	
+	FREE(tmplock, M_TEMP);
+}
+
+void
+devsw_init()
+{
+	devsw_lock_grp = lck_grp_alloc_init("devsw", NULL);
+	assert(devsw_lock_grp != NULL);
+
+	lck_mtx_init(&devsw_lock_list_mtx, devsw_lock_grp, NULL);
+	TAILQ_INIT(&devsw_locks);
+}