xref: /freebsd/sys/compat/linuxkpi/common/src/linux_compat.c (revision 36138969847b231cd98f48272e2bdf88a8dc08dd)
1 /*-
2  * Copyright (c) 2010 Isilon Systems, Inc.
3  * Copyright (c) 2010 iX Systems, Inc.
4  * Copyright (c) 2010 Panasas, Inc.
5  * Copyright (c) 2013-2021 Mellanox Technologies, Ltd.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice unmodified, this list of conditions, and the following
13  *    disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29 
30 #include <sys/cdefs.h>
31 #include "opt_global.h"
32 #include "opt_stack.h"
33 
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/malloc.h>
37 #include <sys/kernel.h>
38 #include <sys/sysctl.h>
39 #include <sys/proc.h>
40 #include <sys/sglist.h>
41 #include <sys/sleepqueue.h>
42 #include <sys/refcount.h>
43 #include <sys/lock.h>
44 #include <sys/mutex.h>
45 #include <sys/bus.h>
46 #include <sys/eventhandler.h>
47 #include <sys/fcntl.h>
48 #include <sys/file.h>
49 #include <sys/filio.h>
50 #include <sys/rwlock.h>
51 #include <sys/mman.h>
52 #include <sys/stack.h>
53 #include <sys/stdarg.h>
54 #include <sys/sysent.h>
55 #include <sys/time.h>
56 #include <sys/user.h>
57 
58 #include <vm/vm.h>
59 #include <vm/pmap.h>
60 #include <vm/vm_object.h>
61 #include <vm/vm_page.h>
62 #include <vm/vm_pager.h>
63 #include <vm/vm_radix.h>
64 
65 #if defined(__i386__) || defined(__amd64__)
66 #include <machine/cputypes.h>
67 #include <machine/md_var.h>
68 #endif
69 
70 #include <linux/kobject.h>
71 #include <linux/cpu.h>
72 #include <linux/device.h>
73 #include <linux/slab.h>
74 #include <linux/module.h>
75 #include <linux/moduleparam.h>
76 #include <linux/cdev.h>
77 #include <linux/file.h>
78 #include <linux/fs.h>
79 #include <linux/sysfs.h>
80 #include <linux/mm.h>
81 #include <linux/io.h>
82 #include <linux/vmalloc.h>
83 #include <linux/netdevice.h>
84 #include <linux/timer.h>
85 #include <linux/interrupt.h>
86 #include <linux/uaccess.h>
87 #include <linux/utsname.h>
88 #include <linux/list.h>
89 #include <linux/kthread.h>
90 #include <linux/kernel.h>
91 #include <linux/compat.h>
92 #include <linux/io-mapping.h>
93 #include <linux/poll.h>
94 #include <linux/smp.h>
95 #include <linux/wait_bit.h>
96 #include <linux/rcupdate.h>
97 #include <linux/interval_tree.h>
98 #include <linux/interval_tree_generic.h>
99 #include <linux/printk.h>
100 #include <linux/seq_file.h>
101 
102 #if defined(__i386__) || defined(__amd64__)
103 #include <asm/smp.h>
104 #include <asm/processor.h>
105 #endif
106 
107 #include <xen/xen.h>
108 #ifdef XENHVM
109 #undef xen_pv_domain
110 #undef xen_initial_domain
111 /* xen/xen-os.h redefines __must_check */
112 #undef __must_check
113 #include <xen/xen-os.h>
114 #endif
115 
116 SYSCTL_NODE(_compat, OID_AUTO, linuxkpi, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
117     "LinuxKPI parameters");
118 
119 int linuxkpi_debug;
120 SYSCTL_INT(_compat_linuxkpi, OID_AUTO, debug, CTLFLAG_RWTUN,
121     &linuxkpi_debug, 0, "Set to enable pr_debug() prints. Clear to disable.");
122 
123 int linuxkpi_rcu_debug;
124 SYSCTL_INT(_compat_linuxkpi, OID_AUTO, rcu_debug, CTLFLAG_RWTUN,
125     &linuxkpi_rcu_debug, 0, "Set to enable RCU warning. Clear to disable.");
126 
127 int linuxkpi_warn_dump_stack = 0;
128 SYSCTL_INT(_compat_linuxkpi, OID_AUTO, warn_dump_stack, CTLFLAG_RWTUN,
129     &linuxkpi_warn_dump_stack, 0,
130     "Set to enable stack traces from WARN_ON(). Clear to disable.");
131 
132 static struct timeval lkpi_net_lastlog;
133 static int lkpi_net_curpps;
134 static int lkpi_net_maxpps = 99;
135 SYSCTL_INT(_compat_linuxkpi, OID_AUTO, net_ratelimit, CTLFLAG_RWTUN,
136     &lkpi_net_maxpps, 0, "Limit number of LinuxKPI net messages per second.");
137 
138 MALLOC_DEFINE(M_KMALLOC, "lkpikmalloc", "Linux kmalloc compat");
139 
140 #include <linux/rbtree.h>
141 /* Undo Linux compat changes. */
142 #undef RB_ROOT
143 #undef file
144 #undef cdev
145 #define	RB_ROOT(head)	(head)->rbh_root
146 
147 static void linux_destroy_dev(struct linux_cdev *);
148 static void linux_cdev_deref(struct linux_cdev *ldev);
149 static struct vm_area_struct *linux_cdev_handle_find(void *handle);
150 
151 cpumask_t cpu_online_mask;
152 static cpumask_t **static_single_cpu_mask;
153 static cpumask_t *static_single_cpu_mask_lcs;
154 struct kobject linux_class_root;
155 struct device linux_root_device;
156 struct class linux_class_misc;
157 struct list_head pci_drivers;
158 struct list_head pci_devices;
159 spinlock_t pci_lock;
160 struct uts_namespace init_uts_ns;
161 
162 unsigned long linux_timer_hz_mask;
163 
164 wait_queue_head_t linux_bit_waitq;
165 wait_queue_head_t linux_var_waitq;
166 
167 int
panic_cmp(struct rb_node * one,struct rb_node * two)168 panic_cmp(struct rb_node *one, struct rb_node *two)
169 {
170 	panic("no cmp");
171 }
172 
173 RB_GENERATE(linux_root, rb_node, __entry, panic_cmp);
174 
175 #define	START(node)	((node)->start)
176 #define	LAST(node)	((node)->last)
177 
178 INTERVAL_TREE_DEFINE(struct interval_tree_node, rb, unsigned long,, START,
179     LAST,, lkpi_interval_tree)
180 
181 static void
linux_device_release(struct device * dev)182 linux_device_release(struct device *dev)
183 {
184 	pr_debug("linux_device_release: %s\n", dev_name(dev));
185 	kfree(dev);
186 }
187 
188 static ssize_t
linux_class_show(struct kobject * kobj,struct attribute * attr,char * buf)189 linux_class_show(struct kobject *kobj, struct attribute *attr, char *buf)
190 {
191 	struct class_attribute *dattr;
192 	ssize_t error;
193 
194 	dattr = container_of(attr, struct class_attribute, attr);
195 	error = -EIO;
196 	if (dattr->show)
197 		error = dattr->show(container_of(kobj, struct class, kobj),
198 		    dattr, buf);
199 	return (error);
200 }
201 
202 static ssize_t
linux_class_store(struct kobject * kobj,struct attribute * attr,const char * buf,size_t count)203 linux_class_store(struct kobject *kobj, struct attribute *attr, const char *buf,
204     size_t count)
205 {
206 	struct class_attribute *dattr;
207 	ssize_t error;
208 
209 	dattr = container_of(attr, struct class_attribute, attr);
210 	error = -EIO;
211 	if (dattr->store)
212 		error = dattr->store(container_of(kobj, struct class, kobj),
213 		    dattr, buf, count);
214 	return (error);
215 }
216 
217 static void
linux_class_release(struct kobject * kobj)218 linux_class_release(struct kobject *kobj)
219 {
220 	struct class *class;
221 
222 	class = container_of(kobj, struct class, kobj);
223 	if (class->class_release)
224 		class->class_release(class);
225 }
226 
227 static const struct sysfs_ops linux_class_sysfs = {
228 	.show  = linux_class_show,
229 	.store = linux_class_store,
230 };
231 
232 const struct kobj_type linux_class_ktype = {
233 	.release = linux_class_release,
234 	.sysfs_ops = &linux_class_sysfs
235 };
236 
237 static void
linux_dev_release(struct kobject * kobj)238 linux_dev_release(struct kobject *kobj)
239 {
240 	struct device *dev;
241 
242 	dev = container_of(kobj, struct device, kobj);
243 	/* This is the precedence defined by linux. */
244 	if (dev->release)
245 		dev->release(dev);
246 	else if (dev->class && dev->class->dev_release)
247 		dev->class->dev_release(dev);
248 }
249 
250 static ssize_t
linux_dev_show(struct kobject * kobj,struct attribute * attr,char * buf)251 linux_dev_show(struct kobject *kobj, struct attribute *attr, char *buf)
252 {
253 	struct device_attribute *dattr;
254 	ssize_t error;
255 
256 	dattr = container_of(attr, struct device_attribute, attr);
257 	error = -EIO;
258 	if (dattr->show)
259 		error = dattr->show(container_of(kobj, struct device, kobj),
260 		    dattr, buf);
261 	return (error);
262 }
263 
264 static ssize_t
linux_dev_store(struct kobject * kobj,struct attribute * attr,const char * buf,size_t count)265 linux_dev_store(struct kobject *kobj, struct attribute *attr, const char *buf,
266     size_t count)
267 {
268 	struct device_attribute *dattr;
269 	ssize_t error;
270 
271 	dattr = container_of(attr, struct device_attribute, attr);
272 	error = -EIO;
273 	if (dattr->store)
274 		error = dattr->store(container_of(kobj, struct device, kobj),
275 		    dattr, buf, count);
276 	return (error);
277 }
278 
279 static const struct sysfs_ops linux_dev_sysfs = {
280 	.show  = linux_dev_show,
281 	.store = linux_dev_store,
282 };
283 
284 const struct kobj_type linux_dev_ktype = {
285 	.release = linux_dev_release,
286 	.sysfs_ops = &linux_dev_sysfs
287 };
288 
289 struct device *
device_create(struct class * class,struct device * parent,dev_t devt,void * drvdata,const char * fmt,...)290 device_create(struct class *class, struct device *parent, dev_t devt,
291     void *drvdata, const char *fmt, ...)
292 {
293 	struct device *dev;
294 	va_list args;
295 
296 	dev = kzalloc(sizeof(*dev), M_WAITOK);
297 	dev->parent = parent;
298 	dev->class = class;
299 	dev->devt = devt;
300 	dev->driver_data = drvdata;
301 	dev->release = linux_device_release;
302 	va_start(args, fmt);
303 	kobject_set_name_vargs(&dev->kobj, fmt, args);
304 	va_end(args);
305 	device_register(dev);
306 
307 	return (dev);
308 }
309 
310 struct device *
device_create_groups_vargs(struct class * class,struct device * parent,dev_t devt,void * drvdata,const struct attribute_group ** groups,const char * fmt,va_list args)311 device_create_groups_vargs(struct class *class, struct device *parent,
312     dev_t devt, void *drvdata, const struct attribute_group **groups,
313     const char *fmt, va_list args)
314 {
315 	struct device *dev = NULL;
316 	int retval = -ENODEV;
317 
318 	if (class == NULL || IS_ERR(class))
319 		goto error;
320 
321 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
322 	if (!dev) {
323 		retval = -ENOMEM;
324 		goto error;
325 	}
326 
327 	dev->devt = devt;
328 	dev->class = class;
329 	dev->parent = parent;
330 	dev->groups = groups;
331 	dev->release = device_create_release;
332 	/* device_initialize() needs the class and parent to be set */
333 	device_initialize(dev);
334 	dev_set_drvdata(dev, drvdata);
335 
336 	retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
337 	if (retval)
338 		goto error;
339 
340 	retval = device_add(dev);
341 	if (retval)
342 		goto error;
343 
344 	return dev;
345 
346 error:
347 	put_device(dev);
348 	return ERR_PTR(retval);
349 }
350 
351 struct class *
lkpi_class_create(const char * name)352 lkpi_class_create(const char *name)
353 {
354 	struct class *class;
355 	int error;
356 
357 	class = kzalloc(sizeof(*class), M_WAITOK);
358 	class->name = name;
359 	class->class_release = linux_class_kfree;
360 	error = class_register(class);
361 	if (error) {
362 		kfree(class);
363 		return (NULL);
364 	}
365 
366 	return (class);
367 }
368 
369 static void
linux_kq_lock(void * arg)370 linux_kq_lock(void *arg)
371 {
372 	spinlock_t *s = arg;
373 
374 	spin_lock(s);
375 }
376 static void
linux_kq_unlock(void * arg)377 linux_kq_unlock(void *arg)
378 {
379 	spinlock_t *s = arg;
380 
381 	spin_unlock(s);
382 }
383 
384 static void
linux_kq_assert_lock(void * arg,int what)385 linux_kq_assert_lock(void *arg, int what)
386 {
387 #ifdef INVARIANTS
388 	spinlock_t *s = arg;
389 
390 	if (what == LA_LOCKED)
391 		mtx_assert(s, MA_OWNED);
392 	else
393 		mtx_assert(s, MA_NOTOWNED);
394 #endif
395 }
396 
397 static void
398 linux_file_kqfilter_poll(struct linux_file *, int);
399 
400 struct linux_file *
linux_file_alloc(void)401 linux_file_alloc(void)
402 {
403 	struct linux_file *filp;
404 
405 	filp = kzalloc(sizeof(*filp), GFP_KERNEL);
406 
407 	/* set initial refcount */
408 	filp->f_count = 1;
409 
410 	/* setup fields needed by kqueue support */
411 	spin_lock_init(&filp->f_kqlock);
412 	knlist_init(&filp->f_selinfo.si_note, &filp->f_kqlock,
413 	    linux_kq_lock, linux_kq_unlock, linux_kq_assert_lock);
414 
415 	return (filp);
416 }
417 
418 void
linux_file_free(struct linux_file * filp)419 linux_file_free(struct linux_file *filp)
420 {
421 	if (filp->_file == NULL) {
422 		if (filp->f_op != NULL && filp->f_op->release != NULL)
423 			filp->f_op->release(filp->f_vnode, filp);
424 		if (filp->f_shmem != NULL)
425 			vm_object_deallocate(filp->f_shmem);
426 		kfree_rcu(filp, rcu);
427 	} else {
428 		/*
429 		 * The close method of the character device or file
430 		 * will free the linux_file structure:
431 		 */
432 		_fdrop(filp->_file, curthread);
433 	}
434 }
435 
436 struct linux_cdev *
cdev_alloc(void)437 cdev_alloc(void)
438 {
439 	struct linux_cdev *cdev;
440 
441 	cdev = kzalloc(sizeof(struct linux_cdev), M_WAITOK);
442 	kobject_init(&cdev->kobj, &linux_cdev_ktype);
443 	cdev->refs = 1;
444 	return (cdev);
445 }
446 
447 static int
linux_cdev_pager_fault(vm_object_t vm_obj,vm_ooffset_t offset,int prot,vm_page_t * mres)448 linux_cdev_pager_fault(vm_object_t vm_obj, vm_ooffset_t offset, int prot,
449     vm_page_t *mres)
450 {
451 	struct vm_area_struct *vmap;
452 
453 	vmap = linux_cdev_handle_find(vm_obj->handle);
454 
455 	MPASS(vmap != NULL);
456 	MPASS(vmap->vm_private_data == vm_obj->handle);
457 
458 	if (likely(vmap->vm_ops != NULL && offset < vmap->vm_len)) {
459 		vm_paddr_t paddr = IDX_TO_OFF(vmap->vm_pfn) + offset;
460 		vm_page_t page;
461 
462 		if (((*mres)->flags & PG_FICTITIOUS) != 0) {
463 			/*
464 			 * If the passed in result page is a fake
465 			 * page, update it with the new physical
466 			 * address.
467 			 */
468 			page = *mres;
469 			vm_page_updatefake(page, paddr, vm_obj->memattr);
470 		} else {
471 			/*
472 			 * Replace the passed in "mres" page with our
473 			 * own fake page and free up the all of the
474 			 * original pages.
475 			 */
476 			VM_OBJECT_WUNLOCK(vm_obj);
477 			page = vm_page_getfake(paddr, vm_obj->memattr);
478 			VM_OBJECT_WLOCK(vm_obj);
479 
480 			vm_page_replace(page, vm_obj, (*mres)->pindex, *mres);
481 			*mres = page;
482 		}
483 		vm_page_valid(page);
484 		return (VM_PAGER_OK);
485 	}
486 	return (VM_PAGER_FAIL);
487 }
488 
489 static int
linux_cdev_pager_populate(vm_object_t vm_obj,vm_pindex_t pidx,int fault_type,vm_prot_t max_prot,vm_pindex_t * first,vm_pindex_t * last)490 linux_cdev_pager_populate(vm_object_t vm_obj, vm_pindex_t pidx, int fault_type,
491     vm_prot_t max_prot, vm_pindex_t *first, vm_pindex_t *last)
492 {
493 	struct vm_area_struct *vmap;
494 	int err;
495 
496 	/* get VM area structure */
497 	vmap = linux_cdev_handle_find(vm_obj->handle);
498 	MPASS(vmap != NULL);
499 	MPASS(vmap->vm_private_data == vm_obj->handle);
500 
501 	VM_OBJECT_WUNLOCK(vm_obj);
502 
503 	linux_set_current(curthread);
504 
505 	down_write(&vmap->vm_mm->mmap_sem);
506 	if (unlikely(vmap->vm_ops == NULL)) {
507 		err = VM_FAULT_SIGBUS;
508 	} else {
509 		struct vm_fault vmf;
510 
511 		/* fill out VM fault structure */
512 		vmf.virtual_address = (void *)(uintptr_t)IDX_TO_OFF(pidx);
513 		vmf.flags = (fault_type & VM_PROT_WRITE) ? FAULT_FLAG_WRITE : 0;
514 		vmf.pgoff = 0;
515 		vmf.page = NULL;
516 		vmf.vma = vmap;
517 
518 		vmap->vm_pfn_count = 0;
519 		vmap->vm_pfn_pcount = &vmap->vm_pfn_count;
520 		vmap->vm_obj = vm_obj;
521 
522 		err = vmap->vm_ops->fault(&vmf);
523 
524 		while (vmap->vm_pfn_count == 0 && err == VM_FAULT_NOPAGE) {
525 			kern_yield(PRI_USER);
526 			err = vmap->vm_ops->fault(&vmf);
527 		}
528 	}
529 
530 	/* translate return code */
531 	switch (err) {
532 	case VM_FAULT_OOM:
533 		err = VM_PAGER_AGAIN;
534 		break;
535 	case VM_FAULT_SIGBUS:
536 		err = VM_PAGER_BAD;
537 		break;
538 	case VM_FAULT_NOPAGE:
539 		/*
540 		 * By contract the fault handler will return having
541 		 * busied all the pages itself. If pidx is already
542 		 * found in the object, it will simply xbusy the first
543 		 * page and return with vm_pfn_count set to 1.
544 		 */
545 		*first = vmap->vm_pfn_first;
546 		*last = *first + vmap->vm_pfn_count - 1;
547 		err = VM_PAGER_OK;
548 		break;
549 	default:
550 		err = VM_PAGER_ERROR;
551 		break;
552 	}
553 	up_write(&vmap->vm_mm->mmap_sem);
554 	VM_OBJECT_WLOCK(vm_obj);
555 	return (err);
556 }
557 
558 static struct rwlock linux_vma_lock;
559 static TAILQ_HEAD(, vm_area_struct) linux_vma_head =
560     TAILQ_HEAD_INITIALIZER(linux_vma_head);
561 
562 static void
linux_cdev_handle_free(struct vm_area_struct * vmap)563 linux_cdev_handle_free(struct vm_area_struct *vmap)
564 {
565 	/* Drop reference on vm_file */
566 	if (vmap->vm_file != NULL)
567 		fput(vmap->vm_file);
568 
569 	/* Drop reference on mm_struct */
570 	mmput(vmap->vm_mm);
571 
572 	kfree(vmap);
573 }
574 
575 static void
linux_cdev_handle_remove(struct vm_area_struct * vmap)576 linux_cdev_handle_remove(struct vm_area_struct *vmap)
577 {
578 	rw_wlock(&linux_vma_lock);
579 	TAILQ_REMOVE(&linux_vma_head, vmap, vm_entry);
580 	rw_wunlock(&linux_vma_lock);
581 }
582 
583 static struct vm_area_struct *
linux_cdev_handle_find(void * handle)584 linux_cdev_handle_find(void *handle)
585 {
586 	struct vm_area_struct *vmap;
587 
588 	rw_rlock(&linux_vma_lock);
589 	TAILQ_FOREACH(vmap, &linux_vma_head, vm_entry) {
590 		if (vmap->vm_private_data == handle)
591 			break;
592 	}
593 	rw_runlock(&linux_vma_lock);
594 	return (vmap);
595 }
596 
597 static int
linux_cdev_pager_ctor(void * handle,vm_ooffset_t size,vm_prot_t prot,vm_ooffset_t foff,struct ucred * cred,u_short * color)598 linux_cdev_pager_ctor(void *handle, vm_ooffset_t size, vm_prot_t prot,
599 		      vm_ooffset_t foff, struct ucred *cred, u_short *color)
600 {
601 
602 	MPASS(linux_cdev_handle_find(handle) != NULL);
603 	*color = 0;
604 	return (0);
605 }
606 
607 static void
linux_cdev_pager_dtor(void * handle)608 linux_cdev_pager_dtor(void *handle)
609 {
610 	const struct vm_operations_struct *vm_ops;
611 	struct vm_area_struct *vmap;
612 
613 	vmap = linux_cdev_handle_find(handle);
614 	MPASS(vmap != NULL);
615 
616 	/*
617 	 * Remove handle before calling close operation to prevent
618 	 * other threads from reusing the handle pointer.
619 	 */
620 	linux_cdev_handle_remove(vmap);
621 
622 	down_write(&vmap->vm_mm->mmap_sem);
623 	vm_ops = vmap->vm_ops;
624 	if (likely(vm_ops != NULL))
625 		vm_ops->close(vmap);
626 	up_write(&vmap->vm_mm->mmap_sem);
627 
628 	linux_cdev_handle_free(vmap);
629 }
630 
631 static struct cdev_pager_ops linux_cdev_pager_ops[2] = {
632   {
633 	/* OBJT_MGTDEVICE */
634 	.cdev_pg_populate	= linux_cdev_pager_populate,
635 	.cdev_pg_ctor	= linux_cdev_pager_ctor,
636 	.cdev_pg_dtor	= linux_cdev_pager_dtor
637   },
638   {
639 	/* OBJT_DEVICE */
640 	.cdev_pg_fault	= linux_cdev_pager_fault,
641 	.cdev_pg_ctor	= linux_cdev_pager_ctor,
642 	.cdev_pg_dtor	= linux_cdev_pager_dtor
643   },
644 };
645 
646 int
zap_vma_ptes(struct vm_area_struct * vma,unsigned long address,unsigned long size)647 zap_vma_ptes(struct vm_area_struct *vma, unsigned long address,
648     unsigned long size)
649 {
650 	struct pctrie_iter pages;
651 	vm_object_t obj;
652 	vm_page_t m;
653 
654 	obj = vma->vm_obj;
655 	if (obj == NULL || (obj->flags & OBJ_UNMANAGED) != 0)
656 		return (-ENOTSUP);
657 	VM_OBJECT_RLOCK(obj);
658 	vm_page_iter_limit_init(&pages, obj, OFF_TO_IDX(address + size));
659 	VM_RADIX_FOREACH_FROM(m, &pages, OFF_TO_IDX(address))
660 		pmap_remove_all(m);
661 	VM_OBJECT_RUNLOCK(obj);
662 	return (0);
663 }
664 
665 void
vma_set_file(struct vm_area_struct * vma,struct linux_file * file)666 vma_set_file(struct vm_area_struct *vma, struct linux_file *file)
667 {
668 	struct linux_file *tmp;
669 
670 	/* Changing an anonymous vma with this is illegal */
671 	get_file(file);
672 	tmp = vma->vm_file;
673 	vma->vm_file = file;
674 	fput(tmp);
675 }
676 
677 static struct file_operations dummy_ldev_ops = {
678 	/* XXXKIB */
679 };
680 
681 static struct linux_cdev dummy_ldev = {
682 	.ops = &dummy_ldev_ops,
683 };
684 
685 #define	LDEV_SI_DTR	0x0001
686 #define	LDEV_SI_REF	0x0002
687 
688 static void
linux_get_fop(struct linux_file * filp,const struct file_operations ** fop,struct linux_cdev ** dev)689 linux_get_fop(struct linux_file *filp, const struct file_operations **fop,
690     struct linux_cdev **dev)
691 {
692 	struct linux_cdev *ldev;
693 	u_int siref;
694 
695 	ldev = filp->f_cdev;
696 	*fop = filp->f_op;
697 	if (ldev != NULL) {
698 		if (ldev->kobj.ktype == &linux_cdev_static_ktype) {
699 			refcount_acquire(&ldev->refs);
700 		} else {
701 			for (siref = ldev->siref;;) {
702 				if ((siref & LDEV_SI_DTR) != 0) {
703 					ldev = &dummy_ldev;
704 					*fop = ldev->ops;
705 					siref = ldev->siref;
706 					MPASS((ldev->siref & LDEV_SI_DTR) == 0);
707 				} else if (atomic_fcmpset_int(&ldev->siref,
708 				    &siref, siref + LDEV_SI_REF)) {
709 					break;
710 				}
711 			}
712 		}
713 	}
714 	*dev = ldev;
715 }
716 
717 static void
linux_drop_fop(struct linux_cdev * ldev)718 linux_drop_fop(struct linux_cdev *ldev)
719 {
720 
721 	if (ldev == NULL)
722 		return;
723 	if (ldev->kobj.ktype == &linux_cdev_static_ktype) {
724 		linux_cdev_deref(ldev);
725 	} else {
726 		MPASS(ldev->kobj.ktype == &linux_cdev_ktype);
727 		MPASS((ldev->siref & ~LDEV_SI_DTR) != 0);
728 		atomic_subtract_int(&ldev->siref, LDEV_SI_REF);
729 	}
730 }
731 
732 #define	OPW(fp,td,code) ({			\
733 	struct file *__fpop;			\
734 	__typeof(code) __retval;		\
735 						\
736 	__fpop = (td)->td_fpop;			\
737 	(td)->td_fpop = (fp);			\
738 	__retval = (code);			\
739 	(td)->td_fpop = __fpop;			\
740 	__retval;				\
741 })
742 
743 static int
linux_dev_fdopen(struct cdev * dev,int fflags,struct thread * td,struct file * file)744 linux_dev_fdopen(struct cdev *dev, int fflags, struct thread *td,
745     struct file *file)
746 {
747 	struct linux_cdev *ldev;
748 	struct linux_file *filp;
749 	const struct file_operations *fop;
750 	int error;
751 
752 	ldev = dev->si_drv1;
753 
754 	filp = linux_file_alloc();
755 	filp->f_dentry = &filp->f_dentry_store;
756 	filp->f_op = ldev->ops;
757 	filp->f_mode = file->f_flag;
758 	filp->f_flags = file->f_flag;
759 	filp->f_vnode = file->f_vnode;
760 	filp->_file = file;
761 	refcount_acquire(&ldev->refs);
762 	filp->f_cdev = ldev;
763 
764 	linux_set_current(td);
765 	linux_get_fop(filp, &fop, &ldev);
766 
767 	if (fop->open != NULL) {
768 		error = -fop->open(file->f_vnode, filp);
769 		if (error != 0) {
770 			linux_drop_fop(ldev);
771 			linux_cdev_deref(filp->f_cdev);
772 			kfree(filp);
773 			return (error);
774 		}
775 	}
776 
777 	/* hold on to the vnode - used for fstat() */
778 	vref(filp->f_vnode);
779 
780 	/* release the file from devfs */
781 	finit(file, filp->f_mode, DTYPE_DEV, filp, &linuxfileops);
782 	linux_drop_fop(ldev);
783 	return (ENXIO);
784 }
785 
786 #define	LINUX_IOCTL_MIN_PTR 0x10000UL
787 #define	LINUX_IOCTL_MAX_PTR (LINUX_IOCTL_MIN_PTR + IOCPARM_MAX)
788 
789 static inline int
linux_remap_address(void ** uaddr,size_t len)790 linux_remap_address(void **uaddr, size_t len)
791 {
792 	uintptr_t uaddr_val = (uintptr_t)(*uaddr);
793 
794 	if (unlikely(uaddr_val >= LINUX_IOCTL_MIN_PTR &&
795 	    uaddr_val < LINUX_IOCTL_MAX_PTR)) {
796 		struct task_struct *pts = current;
797 		if (pts == NULL) {
798 			*uaddr = NULL;
799 			return (1);
800 		}
801 
802 		/* compute data offset */
803 		uaddr_val -= LINUX_IOCTL_MIN_PTR;
804 
805 		/* check that length is within bounds */
806 		if ((len > IOCPARM_MAX) ||
807 		    (uaddr_val + len) > pts->bsd_ioctl_len) {
808 			*uaddr = NULL;
809 			return (1);
810 		}
811 
812 		/* re-add kernel buffer address */
813 		uaddr_val += (uintptr_t)pts->bsd_ioctl_data;
814 
815 		/* update address location */
816 		*uaddr = (void *)uaddr_val;
817 		return (1);
818 	}
819 	return (0);
820 }
821 
822 int
linux_copyin(const void * uaddr,void * kaddr,size_t len)823 linux_copyin(const void *uaddr, void *kaddr, size_t len)
824 {
825 	if (linux_remap_address(__DECONST(void **, &uaddr), len)) {
826 		if (uaddr == NULL)
827 			return (-EFAULT);
828 		memcpy(kaddr, uaddr, len);
829 		return (0);
830 	}
831 	return (-copyin(uaddr, kaddr, len));
832 }
833 
834 int
linux_copyout(const void * kaddr,void * uaddr,size_t len)835 linux_copyout(const void *kaddr, void *uaddr, size_t len)
836 {
837 	if (linux_remap_address(&uaddr, len)) {
838 		if (uaddr == NULL)
839 			return (-EFAULT);
840 		memcpy(uaddr, kaddr, len);
841 		return (0);
842 	}
843 	return (-copyout(kaddr, uaddr, len));
844 }
845 
846 size_t
linux_clear_user(void * _uaddr,size_t _len)847 linux_clear_user(void *_uaddr, size_t _len)
848 {
849 	uint8_t *uaddr = _uaddr;
850 	size_t len = _len;
851 
852 	/* make sure uaddr is aligned before going into the fast loop */
853 	while (((uintptr_t)uaddr & 7) != 0 && len > 7) {
854 		if (subyte(uaddr, 0))
855 			return (_len);
856 		uaddr++;
857 		len--;
858 	}
859 
860 	/* zero 8 bytes at a time */
861 	while (len > 7) {
862 #ifdef __LP64__
863 		if (suword64(uaddr, 0))
864 			return (_len);
865 #else
866 		if (suword32(uaddr, 0))
867 			return (_len);
868 		if (suword32(uaddr + 4, 0))
869 			return (_len);
870 #endif
871 		uaddr += 8;
872 		len -= 8;
873 	}
874 
875 	/* zero fill end, if any */
876 	while (len > 0) {
877 		if (subyte(uaddr, 0))
878 			return (_len);
879 		uaddr++;
880 		len--;
881 	}
882 	return (0);
883 }
884 
885 int
linux_access_ok(const void * uaddr,size_t len)886 linux_access_ok(const void *uaddr, size_t len)
887 {
888 	uintptr_t saddr;
889 	uintptr_t eaddr;
890 
891 	/* get start and end address */
892 	saddr = (uintptr_t)uaddr;
893 	eaddr = (uintptr_t)uaddr + len;
894 
895 	/* verify addresses are valid for userspace */
896 	return ((saddr == eaddr) ||
897 	    (eaddr > saddr && eaddr <= VM_MAXUSER_ADDRESS));
898 }
899 
900 /*
901  * This function should return either EINTR or ERESTART depending on
902  * the signal type sent to this thread:
903  */
904 static int
linux_get_error(struct task_struct * task,int error)905 linux_get_error(struct task_struct *task, int error)
906 {
907 	/* check for signal type interrupt code */
908 	if (error == EINTR || error == ERESTARTSYS || error == ERESTART) {
909 		error = -linux_schedule_get_interrupt_value(task);
910 		if (error == 0)
911 			error = EINTR;
912 	}
913 	return (error);
914 }
915 
916 static int
linux_file_ioctl_sub(struct file * fp,struct linux_file * filp,const struct file_operations * fop,u_long cmd,caddr_t data,struct thread * td)917 linux_file_ioctl_sub(struct file *fp, struct linux_file *filp,
918     const struct file_operations *fop, u_long cmd, caddr_t data,
919     struct thread *td)
920 {
921 	struct task_struct *task = current;
922 	unsigned size;
923 	int error;
924 
925 	size = IOCPARM_LEN(cmd);
926 	/* refer to logic in sys_ioctl() */
927 	if (size > 0) {
928 		/*
929 		 * Setup hint for linux_copyin() and linux_copyout().
930 		 *
931 		 * Background: Linux code expects a user-space address
932 		 * while FreeBSD supplies a kernel-space address.
933 		 */
934 		task->bsd_ioctl_data = data;
935 		task->bsd_ioctl_len = size;
936 		data = (void *)LINUX_IOCTL_MIN_PTR;
937 	} else {
938 		/* fetch user-space pointer */
939 		data = *(void **)data;
940 	}
941 #ifdef COMPAT_FREEBSD32
942 	if (SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
943 		/* try the compat IOCTL handler first */
944 		if (fop->compat_ioctl != NULL) {
945 			error = -OPW(fp, td, fop->compat_ioctl(filp,
946 			    cmd, (u_long)data));
947 		} else {
948 			error = ENOTTY;
949 		}
950 
951 		/* fallback to the regular IOCTL handler, if any */
952 		if (error == ENOTTY && fop->unlocked_ioctl != NULL) {
953 			error = -OPW(fp, td, fop->unlocked_ioctl(filp,
954 			    cmd, (u_long)data));
955 		}
956 	} else
957 #endif
958 	{
959 		if (fop->unlocked_ioctl != NULL) {
960 			error = -OPW(fp, td, fop->unlocked_ioctl(filp,
961 			    cmd, (u_long)data));
962 		} else {
963 			error = ENOTTY;
964 		}
965 	}
966 	if (size > 0) {
967 		task->bsd_ioctl_data = NULL;
968 		task->bsd_ioctl_len = 0;
969 	}
970 
971 	if (error == EWOULDBLOCK) {
972 		/* update kqfilter status, if any */
973 		linux_file_kqfilter_poll(filp,
974 		    LINUX_KQ_FLAG_HAS_READ | LINUX_KQ_FLAG_HAS_WRITE);
975 	} else {
976 		error = linux_get_error(task, error);
977 	}
978 	return (error);
979 }
980 
981 #define	LINUX_POLL_TABLE_NORMAL ((poll_table *)1)
982 
983 /*
984  * This function atomically updates the poll wakeup state and returns
985  * the previous state at the time of update.
986  */
987 static uint8_t
linux_poll_wakeup_state(atomic_t * v,const uint8_t * pstate)988 linux_poll_wakeup_state(atomic_t *v, const uint8_t *pstate)
989 {
990 	int c, old;
991 
992 	c = v->counter;
993 
994 	while ((old = atomic_cmpxchg(v, c, pstate[c])) != c)
995 		c = old;
996 
997 	return (c);
998 }
999 
1000 static int
linux_poll_wakeup_callback(wait_queue_t * wq,unsigned int wq_state,int flags,void * key)1001 linux_poll_wakeup_callback(wait_queue_t *wq, unsigned int wq_state, int flags, void *key)
1002 {
1003 	static const uint8_t state[LINUX_FWQ_STATE_MAX] = {
1004 		[LINUX_FWQ_STATE_INIT] = LINUX_FWQ_STATE_INIT, /* NOP */
1005 		[LINUX_FWQ_STATE_NOT_READY] = LINUX_FWQ_STATE_NOT_READY, /* NOP */
1006 		[LINUX_FWQ_STATE_QUEUED] = LINUX_FWQ_STATE_READY,
1007 		[LINUX_FWQ_STATE_READY] = LINUX_FWQ_STATE_READY, /* NOP */
1008 	};
1009 	struct linux_file *filp = container_of(wq, struct linux_file, f_wait_queue.wq);
1010 
1011 	switch (linux_poll_wakeup_state(&filp->f_wait_queue.state, state)) {
1012 	case LINUX_FWQ_STATE_QUEUED:
1013 		linux_poll_wakeup(filp);
1014 		return (1);
1015 	default:
1016 		return (0);
1017 	}
1018 }
1019 
1020 void
linux_poll_wait(struct linux_file * filp,wait_queue_head_t * wqh,poll_table * p)1021 linux_poll_wait(struct linux_file *filp, wait_queue_head_t *wqh, poll_table *p)
1022 {
1023 	static const uint8_t state[LINUX_FWQ_STATE_MAX] = {
1024 		[LINUX_FWQ_STATE_INIT] = LINUX_FWQ_STATE_NOT_READY,
1025 		[LINUX_FWQ_STATE_NOT_READY] = LINUX_FWQ_STATE_NOT_READY, /* NOP */
1026 		[LINUX_FWQ_STATE_QUEUED] = LINUX_FWQ_STATE_QUEUED, /* NOP */
1027 		[LINUX_FWQ_STATE_READY] = LINUX_FWQ_STATE_QUEUED,
1028 	};
1029 
1030 	/* check if we are called inside the select system call */
1031 	if (p == LINUX_POLL_TABLE_NORMAL)
1032 		selrecord(curthread, &filp->f_selinfo);
1033 
1034 	switch (linux_poll_wakeup_state(&filp->f_wait_queue.state, state)) {
1035 	case LINUX_FWQ_STATE_INIT:
1036 		/* NOTE: file handles can only belong to one wait-queue */
1037 		filp->f_wait_queue.wqh = wqh;
1038 		filp->f_wait_queue.wq.func = &linux_poll_wakeup_callback;
1039 		add_wait_queue(wqh, &filp->f_wait_queue.wq);
1040 		atomic_set(&filp->f_wait_queue.state, LINUX_FWQ_STATE_QUEUED);
1041 		break;
1042 	default:
1043 		break;
1044 	}
1045 }
1046 
1047 static void
linux_poll_wait_dequeue(struct linux_file * filp)1048 linux_poll_wait_dequeue(struct linux_file *filp)
1049 {
1050 	static const uint8_t state[LINUX_FWQ_STATE_MAX] = {
1051 		[LINUX_FWQ_STATE_INIT] = LINUX_FWQ_STATE_INIT,	/* NOP */
1052 		[LINUX_FWQ_STATE_NOT_READY] = LINUX_FWQ_STATE_INIT,
1053 		[LINUX_FWQ_STATE_QUEUED] = LINUX_FWQ_STATE_INIT,
1054 		[LINUX_FWQ_STATE_READY] = LINUX_FWQ_STATE_INIT,
1055 	};
1056 
1057 	seldrain(&filp->f_selinfo);
1058 
1059 	switch (linux_poll_wakeup_state(&filp->f_wait_queue.state, state)) {
1060 	case LINUX_FWQ_STATE_NOT_READY:
1061 	case LINUX_FWQ_STATE_QUEUED:
1062 	case LINUX_FWQ_STATE_READY:
1063 		remove_wait_queue(filp->f_wait_queue.wqh, &filp->f_wait_queue.wq);
1064 		break;
1065 	default:
1066 		break;
1067 	}
1068 }
1069 
1070 void
linux_poll_wakeup(struct linux_file * filp)1071 linux_poll_wakeup(struct linux_file *filp)
1072 {
1073 	/* this function should be NULL-safe */
1074 	if (filp == NULL)
1075 		return;
1076 
1077 	selwakeup(&filp->f_selinfo);
1078 
1079 	spin_lock(&filp->f_kqlock);
1080 	filp->f_kqflags |= LINUX_KQ_FLAG_NEED_READ |
1081 	    LINUX_KQ_FLAG_NEED_WRITE;
1082 
1083 	/* make sure the "knote" gets woken up */
1084 	KNOTE_LOCKED(&filp->f_selinfo.si_note, 1);
1085 	spin_unlock(&filp->f_kqlock);
1086 }
1087 
1088 static struct linux_file *
__get_file_rcu(struct linux_file ** f)1089 __get_file_rcu(struct linux_file **f)
1090 {
1091 	struct linux_file *file1, *file2;
1092 
1093 	file1 = READ_ONCE(*f);
1094 	if (file1 == NULL)
1095 		return (NULL);
1096 
1097 	if (!refcount_acquire_if_not_zero(
1098 	    file1->_file == NULL ? &file1->f_count : &file1->_file->f_count))
1099 		return (ERR_PTR(-EAGAIN));
1100 
1101 	file2 = READ_ONCE(*f);
1102 	if (file2 == file1)
1103 		return (file2);
1104 
1105 	fput(file1);
1106 	return (ERR_PTR(-EAGAIN));
1107 }
1108 
1109 struct linux_file *
linux_get_file_rcu(struct linux_file ** f)1110 linux_get_file_rcu(struct linux_file **f)
1111 {
1112 	struct linux_file *file1;
1113 
1114 	for (;;) {
1115 		file1 = __get_file_rcu(f);
1116 		if (file1 == NULL)
1117 			return (NULL);
1118 
1119 		if (IS_ERR(file1))
1120 			continue;
1121 
1122 		return (file1);
1123 	}
1124 }
1125 
1126 struct linux_file *
get_file_active(struct linux_file ** f)1127 get_file_active(struct linux_file **f)
1128 {
1129 	struct linux_file *file1;
1130 
1131 	rcu_read_lock();
1132 	file1 = __get_file_rcu(f);
1133 	rcu_read_unlock();
1134 	if (IS_ERR(file1))
1135 		file1 = NULL;
1136 
1137 	return (file1);
1138 }
1139 
1140 static void
linux_file_kqfilter_detach(struct knote * kn)1141 linux_file_kqfilter_detach(struct knote *kn)
1142 {
1143 	struct linux_file *filp = kn->kn_hook;
1144 
1145 	spin_lock(&filp->f_kqlock);
1146 	knlist_remove(&filp->f_selinfo.si_note, kn, 1);
1147 	spin_unlock(&filp->f_kqlock);
1148 }
1149 
1150 static int
linux_file_kqfilter_read_event(struct knote * kn,long hint)1151 linux_file_kqfilter_read_event(struct knote *kn, long hint)
1152 {
1153 	struct linux_file *filp = kn->kn_hook;
1154 
1155 	mtx_assert(&filp->f_kqlock, MA_OWNED);
1156 
1157 	return ((filp->f_kqflags & LINUX_KQ_FLAG_NEED_READ) ? 1 : 0);
1158 }
1159 
1160 static int
linux_file_kqfilter_write_event(struct knote * kn,long hint)1161 linux_file_kqfilter_write_event(struct knote *kn, long hint)
1162 {
1163 	struct linux_file *filp = kn->kn_hook;
1164 
1165 	mtx_assert(&filp->f_kqlock, MA_OWNED);
1166 
1167 	return ((filp->f_kqflags & LINUX_KQ_FLAG_NEED_WRITE) ? 1 : 0);
1168 }
1169 
1170 static const struct filterops linux_dev_kqfiltops_read = {
1171 	.f_isfd = 1,
1172 	.f_detach = linux_file_kqfilter_detach,
1173 	.f_event = linux_file_kqfilter_read_event,
1174 	.f_copy = knote_triv_copy,
1175 };
1176 
1177 static const struct filterops linux_dev_kqfiltops_write = {
1178 	.f_isfd = 1,
1179 	.f_detach = linux_file_kqfilter_detach,
1180 	.f_event = linux_file_kqfilter_write_event,
1181 	.f_copy = knote_triv_copy,
1182 };
1183 
1184 static void
linux_file_kqfilter_poll(struct linux_file * filp,int kqflags)1185 linux_file_kqfilter_poll(struct linux_file *filp, int kqflags)
1186 {
1187 	struct thread *td;
1188 	const struct file_operations *fop;
1189 	struct linux_cdev *ldev;
1190 	int temp;
1191 
1192 	if ((filp->f_kqflags & kqflags) == 0)
1193 		return;
1194 
1195 	td = curthread;
1196 
1197 	linux_get_fop(filp, &fop, &ldev);
1198 	/* get the latest polling state */
1199 	temp = OPW(filp->_file, td, fop->poll(filp, NULL));
1200 	linux_drop_fop(ldev);
1201 
1202 	spin_lock(&filp->f_kqlock);
1203 	/* clear kqflags */
1204 	filp->f_kqflags &= ~(LINUX_KQ_FLAG_NEED_READ |
1205 	    LINUX_KQ_FLAG_NEED_WRITE);
1206 	/* update kqflags */
1207 	if ((temp & (POLLIN | POLLOUT)) != 0) {
1208 		if ((temp & POLLIN) != 0)
1209 			filp->f_kqflags |= LINUX_KQ_FLAG_NEED_READ;
1210 		if ((temp & POLLOUT) != 0)
1211 			filp->f_kqflags |= LINUX_KQ_FLAG_NEED_WRITE;
1212 
1213 		/* make sure the "knote" gets woken up */
1214 		KNOTE_LOCKED(&filp->f_selinfo.si_note, 0);
1215 	}
1216 	spin_unlock(&filp->f_kqlock);
1217 }
1218 
1219 static int
linux_file_kqfilter(struct file * file,struct knote * kn)1220 linux_file_kqfilter(struct file *file, struct knote *kn)
1221 {
1222 	struct linux_file *filp;
1223 	struct thread *td;
1224 	int error;
1225 
1226 	td = curthread;
1227 	filp = (struct linux_file *)file->f_data;
1228 	filp->f_flags = file->f_flag;
1229 	if (filp->f_op->poll == NULL)
1230 		return (EINVAL);
1231 
1232 	spin_lock(&filp->f_kqlock);
1233 	switch (kn->kn_filter) {
1234 	case EVFILT_READ:
1235 		filp->f_kqflags |= LINUX_KQ_FLAG_HAS_READ;
1236 		kn->kn_fop = &linux_dev_kqfiltops_read;
1237 		kn->kn_hook = filp;
1238 		knlist_add(&filp->f_selinfo.si_note, kn, 1);
1239 		error = 0;
1240 		break;
1241 	case EVFILT_WRITE:
1242 		filp->f_kqflags |= LINUX_KQ_FLAG_HAS_WRITE;
1243 		kn->kn_fop = &linux_dev_kqfiltops_write;
1244 		kn->kn_hook = filp;
1245 		knlist_add(&filp->f_selinfo.si_note, kn, 1);
1246 		error = 0;
1247 		break;
1248 	default:
1249 		error = EINVAL;
1250 		break;
1251 	}
1252 	spin_unlock(&filp->f_kqlock);
1253 
1254 	if (error == 0) {
1255 		linux_set_current(td);
1256 
1257 		/* update kqfilter status, if any */
1258 		linux_file_kqfilter_poll(filp,
1259 		    LINUX_KQ_FLAG_HAS_READ | LINUX_KQ_FLAG_HAS_WRITE);
1260 	}
1261 	return (error);
1262 }
1263 
1264 static int
linux_file_mmap_single(struct file * fp,const struct file_operations * fop,vm_ooffset_t * offset,vm_size_t size,struct vm_object ** object,int nprot,bool is_shared,struct thread * td)1265 linux_file_mmap_single(struct file *fp, const struct file_operations *fop,
1266     vm_ooffset_t *offset, vm_size_t size, struct vm_object **object,
1267     int nprot, bool is_shared, struct thread *td)
1268 {
1269 	struct task_struct *task;
1270 	struct vm_area_struct *vmap;
1271 	struct mm_struct *mm;
1272 	struct linux_file *filp;
1273 	vm_memattr_t attr;
1274 	int error;
1275 
1276 	filp = (struct linux_file *)fp->f_data;
1277 	filp->f_flags = fp->f_flag;
1278 
1279 	if (fop->mmap == NULL)
1280 		return (EOPNOTSUPP);
1281 
1282 	linux_set_current(td);
1283 
1284 	/*
1285 	 * The same VM object might be shared by multiple processes
1286 	 * and the mm_struct is usually freed when a process exits.
1287 	 *
1288 	 * The atomic reference below makes sure the mm_struct is
1289 	 * available as long as the vmap is in the linux_vma_head.
1290 	 */
1291 	task = current;
1292 	mm = task->mm;
1293 	if (atomic_inc_not_zero(&mm->mm_users) == 0)
1294 		return (EINVAL);
1295 
1296 	vmap = kzalloc(sizeof(*vmap), GFP_KERNEL);
1297 	vmap->vm_start = 0;
1298 	vmap->vm_end = size;
1299 	vmap->vm_pgoff = *offset / PAGE_SIZE;
1300 	vmap->vm_pfn = 0;
1301 	vmap->vm_flags = vmap->vm_page_prot = (nprot & VM_PROT_ALL);
1302 	if (is_shared)
1303 		vmap->vm_flags |= VM_SHARED;
1304 	vmap->vm_ops = NULL;
1305 	vmap->vm_file = get_file(filp);
1306 	vmap->vm_mm = mm;
1307 
1308 	if (unlikely(down_write_killable(&vmap->vm_mm->mmap_sem))) {
1309 		error = linux_get_error(task, EINTR);
1310 	} else {
1311 		error = -OPW(fp, td, fop->mmap(filp, vmap));
1312 		error = linux_get_error(task, error);
1313 		up_write(&vmap->vm_mm->mmap_sem);
1314 	}
1315 
1316 	if (error != 0) {
1317 		linux_cdev_handle_free(vmap);
1318 		return (error);
1319 	}
1320 
1321 	attr = pgprot2cachemode(vmap->vm_page_prot);
1322 
1323 	if (vmap->vm_ops != NULL) {
1324 		struct vm_area_struct *ptr;
1325 		void *vm_private_data;
1326 		bool vm_no_fault;
1327 
1328 		if (vmap->vm_ops->open == NULL ||
1329 		    vmap->vm_ops->close == NULL ||
1330 		    vmap->vm_private_data == NULL) {
1331 			/* free allocated VM area struct */
1332 			linux_cdev_handle_free(vmap);
1333 			return (EINVAL);
1334 		}
1335 
1336 		vm_private_data = vmap->vm_private_data;
1337 
1338 		rw_wlock(&linux_vma_lock);
1339 		TAILQ_FOREACH(ptr, &linux_vma_head, vm_entry) {
1340 			if (ptr->vm_private_data == vm_private_data)
1341 				break;
1342 		}
1343 		/* check if there is an existing VM area struct */
1344 		if (ptr != NULL) {
1345 			/* check if the VM area structure is invalid */
1346 			if (ptr->vm_ops == NULL ||
1347 			    ptr->vm_ops->open == NULL ||
1348 			    ptr->vm_ops->close == NULL) {
1349 				error = ESTALE;
1350 				vm_no_fault = 1;
1351 			} else {
1352 				error = EEXIST;
1353 				vm_no_fault = (ptr->vm_ops->fault == NULL);
1354 			}
1355 		} else {
1356 			/* insert VM area structure into list */
1357 			TAILQ_INSERT_TAIL(&linux_vma_head, vmap, vm_entry);
1358 			error = 0;
1359 			vm_no_fault = (vmap->vm_ops->fault == NULL);
1360 		}
1361 		rw_wunlock(&linux_vma_lock);
1362 
1363 		if (error != 0) {
1364 			/* free allocated VM area struct */
1365 			linux_cdev_handle_free(vmap);
1366 			/* check for stale VM area struct */
1367 			if (error != EEXIST)
1368 				return (error);
1369 		}
1370 
1371 		/* check if there is no fault handler */
1372 		if (vm_no_fault) {
1373 			*object = cdev_pager_allocate(vm_private_data, OBJT_DEVICE,
1374 			    &linux_cdev_pager_ops[1], size, nprot, *offset,
1375 			    td->td_ucred);
1376 		} else {
1377 			*object = cdev_pager_allocate(vm_private_data, OBJT_MGTDEVICE,
1378 			    &linux_cdev_pager_ops[0], size, nprot, *offset,
1379 			    td->td_ucred);
1380 		}
1381 
1382 		/* check if allocating the VM object failed */
1383 		if (*object == NULL) {
1384 			if (error == 0) {
1385 				/* remove VM area struct from list */
1386 				linux_cdev_handle_remove(vmap);
1387 				/* free allocated VM area struct */
1388 				linux_cdev_handle_free(vmap);
1389 			}
1390 			return (EINVAL);
1391 		}
1392 	} else {
1393 		struct sglist *sg;
1394 
1395 		sg = sglist_alloc(1, M_WAITOK);
1396 		sglist_append_phys(sg,
1397 		    (vm_paddr_t)vmap->vm_pfn << PAGE_SHIFT, vmap->vm_len);
1398 
1399 		*object = vm_pager_allocate(OBJT_SG, sg, vmap->vm_len,
1400 		    nprot, 0, td->td_ucred);
1401 
1402 		linux_cdev_handle_free(vmap);
1403 
1404 		if (*object == NULL) {
1405 			sglist_free(sg);
1406 			return (EINVAL);
1407 		}
1408 	}
1409 
1410 	if (attr != VM_MEMATTR_DEFAULT) {
1411 		VM_OBJECT_WLOCK(*object);
1412 		vm_object_set_memattr(*object, attr);
1413 		VM_OBJECT_WUNLOCK(*object);
1414 	}
1415 	*offset = 0;
1416 	return (0);
1417 }
1418 
1419 struct cdevsw linuxcdevsw = {
1420 	.d_version = D_VERSION,
1421 	.d_fdopen = linux_dev_fdopen,
1422 	.d_name = "lkpidev",
1423 };
1424 
1425 static int
linux_file_read(struct file * file,struct uio * uio,struct ucred * active_cred,int flags,struct thread * td)1426 linux_file_read(struct file *file, struct uio *uio, struct ucred *active_cred,
1427     int flags, struct thread *td)
1428 {
1429 	struct linux_file *filp;
1430 	const struct file_operations *fop;
1431 	struct linux_cdev *ldev;
1432 	ssize_t bytes;
1433 	int error;
1434 
1435 	error = 0;
1436 	filp = (struct linux_file *)file->f_data;
1437 	filp->f_flags = file->f_flag;
1438 	/* XXX no support for I/O vectors currently */
1439 	if (uio->uio_iovcnt != 1)
1440 		return (EOPNOTSUPP);
1441 	if (uio->uio_resid > DEVFS_IOSIZE_MAX)
1442 		return (EINVAL);
1443 	linux_set_current(td);
1444 	linux_get_fop(filp, &fop, &ldev);
1445 	if (fop->read != NULL) {
1446 		bytes = OPW(file, td, fop->read(filp,
1447 		    uio->uio_iov->iov_base,
1448 		    uio->uio_iov->iov_len, &uio->uio_offset));
1449 		if (bytes >= 0) {
1450 			uio->uio_iov->iov_base =
1451 			    ((uint8_t *)uio->uio_iov->iov_base) + bytes;
1452 			uio->uio_iov->iov_len -= bytes;
1453 			uio->uio_resid -= bytes;
1454 		} else {
1455 			error = linux_get_error(current, -bytes);
1456 		}
1457 	} else
1458 		error = ENXIO;
1459 
1460 	/* update kqfilter status, if any */
1461 	linux_file_kqfilter_poll(filp, LINUX_KQ_FLAG_HAS_READ);
1462 	linux_drop_fop(ldev);
1463 
1464 	return (error);
1465 }
1466 
1467 static int
linux_file_write(struct file * file,struct uio * uio,struct ucred * active_cred,int flags,struct thread * td)1468 linux_file_write(struct file *file, struct uio *uio, struct ucred *active_cred,
1469     int flags, struct thread *td)
1470 {
1471 	struct linux_file *filp;
1472 	const struct file_operations *fop;
1473 	struct linux_cdev *ldev;
1474 	ssize_t bytes;
1475 	int error;
1476 
1477 	filp = (struct linux_file *)file->f_data;
1478 	filp->f_flags = file->f_flag;
1479 	/* XXX no support for I/O vectors currently */
1480 	if (uio->uio_iovcnt != 1)
1481 		return (EOPNOTSUPP);
1482 	if (uio->uio_resid > DEVFS_IOSIZE_MAX)
1483 		return (EINVAL);
1484 	linux_set_current(td);
1485 	linux_get_fop(filp, &fop, &ldev);
1486 	if (fop->write != NULL) {
1487 		bytes = OPW(file, td, fop->write(filp,
1488 		    uio->uio_iov->iov_base,
1489 		    uio->uio_iov->iov_len, &uio->uio_offset));
1490 		if (bytes >= 0) {
1491 			uio->uio_iov->iov_base =
1492 			    ((uint8_t *)uio->uio_iov->iov_base) + bytes;
1493 			uio->uio_iov->iov_len -= bytes;
1494 			uio->uio_resid -= bytes;
1495 			error = 0;
1496 		} else {
1497 			error = linux_get_error(current, -bytes);
1498 		}
1499 	} else
1500 		error = ENXIO;
1501 
1502 	/* update kqfilter status, if any */
1503 	linux_file_kqfilter_poll(filp, LINUX_KQ_FLAG_HAS_WRITE);
1504 
1505 	linux_drop_fop(ldev);
1506 
1507 	return (error);
1508 }
1509 
1510 static int
linux_file_poll(struct file * file,int events,struct ucred * active_cred,struct thread * td)1511 linux_file_poll(struct file *file, int events, struct ucred *active_cred,
1512     struct thread *td)
1513 {
1514 	struct linux_file *filp;
1515 	const struct file_operations *fop;
1516 	struct linux_cdev *ldev;
1517 	int revents;
1518 
1519 	filp = (struct linux_file *)file->f_data;
1520 	filp->f_flags = file->f_flag;
1521 	linux_set_current(td);
1522 	linux_get_fop(filp, &fop, &ldev);
1523 	if (fop->poll != NULL) {
1524 		revents = OPW(file, td, fop->poll(filp,
1525 		    LINUX_POLL_TABLE_NORMAL)) & events;
1526 	} else {
1527 		revents = 0;
1528 	}
1529 	linux_drop_fop(ldev);
1530 	return (revents);
1531 }
1532 
1533 static int
linux_file_close(struct file * file,struct thread * td)1534 linux_file_close(struct file *file, struct thread *td)
1535 {
1536 	struct linux_file *filp;
1537 	int (*release)(struct inode *, struct linux_file *);
1538 	const struct file_operations *fop;
1539 	struct linux_cdev *ldev;
1540 	int error;
1541 
1542 	filp = (struct linux_file *)file->f_data;
1543 
1544 	KASSERT(file_count(filp) == 0,
1545 	    ("File refcount(%d) is not zero", file_count(filp)));
1546 
1547 	if (td == NULL)
1548 		td = curthread;
1549 
1550 	error = 0;
1551 	filp->f_flags = file->f_flag;
1552 	linux_set_current(td);
1553 	linux_poll_wait_dequeue(filp);
1554 	linux_get_fop(filp, &fop, &ldev);
1555 	/*
1556 	 * Always use the real release function, if any, to avoid
1557 	 * leaking device resources:
1558 	 */
1559 	release = filp->f_op->release;
1560 	if (release != NULL)
1561 		error = -OPW(file, td, release(filp->f_vnode, filp));
1562 	funsetown(&filp->f_sigio);
1563 	if (filp->f_vnode != NULL)
1564 		vrele(filp->f_vnode);
1565 	linux_drop_fop(ldev);
1566 	ldev = filp->f_cdev;
1567 	if (ldev != NULL)
1568 		linux_cdev_deref(ldev);
1569 	linux_synchronize_rcu(RCU_TYPE_REGULAR);
1570 	kfree(filp);
1571 
1572 	return (error);
1573 }
1574 
1575 static int
linux_file_ioctl(struct file * fp,u_long cmd,void * data,struct ucred * cred,struct thread * td)1576 linux_file_ioctl(struct file *fp, u_long cmd, void *data, struct ucred *cred,
1577     struct thread *td)
1578 {
1579 	struct linux_file *filp;
1580 	const struct file_operations *fop;
1581 	struct linux_cdev *ldev;
1582 	struct fiodgname_arg *fgn;
1583 	const char *p;
1584 	int error, i;
1585 
1586 	error = 0;
1587 	filp = (struct linux_file *)fp->f_data;
1588 	filp->f_flags = fp->f_flag;
1589 	linux_get_fop(filp, &fop, &ldev);
1590 
1591 	linux_set_current(td);
1592 	switch (cmd) {
1593 	case FIONBIO:
1594 		break;
1595 	case FIOASYNC:
1596 		if (fop->fasync == NULL)
1597 			break;
1598 		error = -OPW(fp, td, fop->fasync(0, filp, fp->f_flag & FASYNC));
1599 		break;
1600 	case FIOSETOWN:
1601 		error = fsetown(*(int *)data, &filp->f_sigio);
1602 		if (error == 0) {
1603 			if (fop->fasync == NULL)
1604 				break;
1605 			error = -OPW(fp, td, fop->fasync(0, filp,
1606 			    fp->f_flag & FASYNC));
1607 		}
1608 		break;
1609 	case FIOGETOWN:
1610 		*(int *)data = fgetown(&filp->f_sigio);
1611 		break;
1612 	case FIODGNAME:
1613 #ifdef	COMPAT_FREEBSD32
1614 	case FIODGNAME_32:
1615 #endif
1616 		if (filp->f_cdev == NULL || filp->f_cdev->cdev == NULL) {
1617 			error = ENXIO;
1618 			break;
1619 		}
1620 		fgn = data;
1621 		p = devtoname(filp->f_cdev->cdev);
1622 		i = strlen(p) + 1;
1623 		if (i > fgn->len) {
1624 			error = EINVAL;
1625 			break;
1626 		}
1627 		error = copyout(p, fiodgname_buf_get_ptr(fgn, cmd), i);
1628 		break;
1629 	default:
1630 		error = linux_file_ioctl_sub(fp, filp, fop, cmd, data, td);
1631 		break;
1632 	}
1633 	linux_drop_fop(ldev);
1634 	return (error);
1635 }
1636 
1637 static int
linux_file_mmap_sub(struct thread * td,vm_size_t objsize,vm_prot_t prot,vm_prot_t maxprot,int flags,struct file * fp,vm_ooffset_t * foff,const struct file_operations * fop,vm_object_t * objp)1638 linux_file_mmap_sub(struct thread *td, vm_size_t objsize, vm_prot_t prot,
1639     vm_prot_t maxprot, int flags, struct file *fp,
1640     vm_ooffset_t *foff, const struct file_operations *fop, vm_object_t *objp)
1641 {
1642 	/*
1643 	 * Character devices do not provide private mappings
1644 	 * of any kind:
1645 	 */
1646 	if ((maxprot & VM_PROT_WRITE) == 0 &&
1647 	    (prot & VM_PROT_WRITE) != 0)
1648 		return (EACCES);
1649 	if ((flags & (MAP_PRIVATE | MAP_COPY)) != 0)
1650 		return (EINVAL);
1651 
1652 	return (linux_file_mmap_single(fp, fop, foff, objsize, objp,
1653 	    (int)prot, (flags & MAP_SHARED) ? true : false, td));
1654 }
1655 
1656 static int
linux_file_mmap(struct file * fp,vm_map_t map,vm_offset_t * addr,vm_size_t size,vm_prot_t prot,vm_prot_t cap_maxprot,int flags,vm_ooffset_t foff,struct thread * td)1657 linux_file_mmap(struct file *fp, vm_map_t map, vm_offset_t *addr, vm_size_t size,
1658     vm_prot_t prot, vm_prot_t cap_maxprot, int flags, vm_ooffset_t foff,
1659     struct thread *td)
1660 {
1661 	struct linux_file *filp;
1662 	const struct file_operations *fop;
1663 	struct linux_cdev *ldev;
1664 	struct mount *mp;
1665 	struct vnode *vp;
1666 	vm_object_t object;
1667 	vm_prot_t maxprot;
1668 	int error;
1669 
1670 	filp = (struct linux_file *)fp->f_data;
1671 
1672 	vp = filp->f_vnode;
1673 	if (vp == NULL)
1674 		return (EOPNOTSUPP);
1675 
1676 	/*
1677 	 * Ensure that file and memory protections are
1678 	 * compatible.
1679 	 */
1680 	mp = vp->v_mount;
1681 	if (mp != NULL && (mp->mnt_flag & MNT_NOEXEC) != 0) {
1682 		maxprot = VM_PROT_NONE;
1683 		if ((prot & VM_PROT_EXECUTE) != 0)
1684 			return (EACCES);
1685 	} else
1686 		maxprot = VM_PROT_EXECUTE;
1687 	if ((fp->f_flag & FREAD) != 0)
1688 		maxprot |= VM_PROT_READ;
1689 	else if ((prot & VM_PROT_READ) != 0)
1690 		return (EACCES);
1691 
1692 	/*
1693 	 * If we are sharing potential changes via MAP_SHARED and we
1694 	 * are trying to get write permission although we opened it
1695 	 * without asking for it, bail out.
1696 	 *
1697 	 * Note that most character devices always share mappings.
1698 	 *
1699 	 * Rely on linux_file_mmap_sub() to fail invalid MAP_PRIVATE
1700 	 * requests rather than doing it here.
1701 	 */
1702 	if ((flags & MAP_SHARED) != 0) {
1703 		if ((fp->f_flag & FWRITE) != 0)
1704 			maxprot |= VM_PROT_WRITE;
1705 		else if ((prot & VM_PROT_WRITE) != 0)
1706 			return (EACCES);
1707 	}
1708 	maxprot &= cap_maxprot;
1709 
1710 	linux_get_fop(filp, &fop, &ldev);
1711 	error = linux_file_mmap_sub(td, size, prot, maxprot, flags, fp,
1712 	    &foff, fop, &object);
1713 	if (error != 0)
1714 		goto out;
1715 
1716 	error = vm_mmap_object(map, addr, size, prot, maxprot, flags, object,
1717 	    foff, FALSE, td);
1718 	if (error != 0)
1719 		vm_object_deallocate(object);
1720 out:
1721 	linux_drop_fop(ldev);
1722 	return (error);
1723 }
1724 
1725 static int
linux_file_stat(struct file * fp,struct stat * sb,struct ucred * active_cred)1726 linux_file_stat(struct file *fp, struct stat *sb, struct ucred *active_cred)
1727 {
1728 	struct linux_file *filp;
1729 	struct vnode *vp;
1730 	int error;
1731 
1732 	filp = (struct linux_file *)fp->f_data;
1733 	if (filp->f_vnode == NULL)
1734 		return (EOPNOTSUPP);
1735 
1736 	vp = filp->f_vnode;
1737 
1738 	vn_lock(vp, LK_SHARED | LK_RETRY);
1739 	error = VOP_STAT(vp, sb, curthread->td_ucred, NOCRED);
1740 	VOP_UNLOCK(vp);
1741 
1742 	return (error);
1743 }
1744 
1745 static int
linux_file_fill_kinfo(struct file * fp,struct kinfo_file * kif,struct filedesc * fdp)1746 linux_file_fill_kinfo(struct file *fp, struct kinfo_file *kif,
1747     struct filedesc *fdp)
1748 {
1749 	struct linux_file *filp;
1750 	struct vnode *vp;
1751 	int error;
1752 
1753 	filp = fp->f_data;
1754 	vp = filp->f_vnode;
1755 	if (vp == NULL) {
1756 		error = 0;
1757 		kif->kf_type = KF_TYPE_DEV;
1758 	} else {
1759 		vref(vp);
1760 		FILEDESC_SUNLOCK(fdp);
1761 		error = vn_fill_kinfo_vnode(vp, kif);
1762 		vrele(vp);
1763 		kif->kf_type = KF_TYPE_VNODE;
1764 		FILEDESC_SLOCK(fdp);
1765 	}
1766 	return (error);
1767 }
1768 
1769 unsigned int
linux_iminor(struct inode * inode)1770 linux_iminor(struct inode *inode)
1771 {
1772 	struct linux_cdev *ldev;
1773 
1774 	if (inode == NULL || inode->v_rdev == NULL ||
1775 	    inode->v_rdev->si_devsw != &linuxcdevsw)
1776 		return (-1U);
1777 	ldev = inode->v_rdev->si_drv1;
1778 	if (ldev == NULL)
1779 		return (-1U);
1780 
1781 	return (minor(ldev->dev));
1782 }
1783 
1784 static int
linux_file_kcmp(struct file * fp1,struct file * fp2,struct thread * td)1785 linux_file_kcmp(struct file *fp1, struct file *fp2, struct thread *td)
1786 {
1787 	struct linux_file *filp1, *filp2;
1788 
1789 	if (fp2->f_type != DTYPE_DEV)
1790 		return (3);
1791 
1792 	filp1 = fp1->f_data;
1793 	filp2 = fp2->f_data;
1794 	return (kcmp_cmp((uintptr_t)filp1->f_cdev, (uintptr_t)filp2->f_cdev));
1795 }
1796 
1797 const struct fileops linuxfileops = {
1798 	.fo_read = linux_file_read,
1799 	.fo_write = linux_file_write,
1800 	.fo_truncate = invfo_truncate,
1801 	.fo_kqfilter = linux_file_kqfilter,
1802 	.fo_stat = linux_file_stat,
1803 	.fo_fill_kinfo = linux_file_fill_kinfo,
1804 	.fo_poll = linux_file_poll,
1805 	.fo_close = linux_file_close,
1806 	.fo_ioctl = linux_file_ioctl,
1807 	.fo_mmap = linux_file_mmap,
1808 	.fo_chmod = invfo_chmod,
1809 	.fo_chown = invfo_chown,
1810 	.fo_sendfile = invfo_sendfile,
1811 	.fo_cmp = linux_file_kcmp,
1812 	.fo_flags = DFLAG_PASSABLE,
1813 };
1814 
1815 /*
1816  * Hash of vmmap addresses.  This is infrequently accessed and does not
1817  * need to be particularly large.  This is done because we must store the
1818  * caller's idea of the map size to properly unmap.
1819  */
1820 struct vmmap {
1821 	LIST_ENTRY(vmmap)	vm_next;
1822 	void 			*vm_addr;
1823 	unsigned long		vm_size;
1824 };
1825 
1826 struct vmmaphd {
1827 	struct vmmap *lh_first;
1828 };
1829 #define	VMMAP_HASH_SIZE	64
1830 #define	VMMAP_HASH_MASK	(VMMAP_HASH_SIZE - 1)
1831 #define	VM_HASH(addr)	((uintptr_t)(addr) >> PAGE_SHIFT) & VMMAP_HASH_MASK
1832 static struct vmmaphd vmmaphead[VMMAP_HASH_SIZE];
1833 static struct mtx vmmaplock;
1834 
1835 static void
vmmap_add(void * addr,unsigned long size)1836 vmmap_add(void *addr, unsigned long size)
1837 {
1838 	struct vmmap *vmmap;
1839 
1840 	vmmap = kmalloc(sizeof(*vmmap), GFP_KERNEL);
1841 	mtx_lock(&vmmaplock);
1842 	vmmap->vm_size = size;
1843 	vmmap->vm_addr = addr;
1844 	LIST_INSERT_HEAD(&vmmaphead[VM_HASH(addr)], vmmap, vm_next);
1845 	mtx_unlock(&vmmaplock);
1846 }
1847 
1848 static struct vmmap *
vmmap_remove(void * addr)1849 vmmap_remove(void *addr)
1850 {
1851 	struct vmmap *vmmap;
1852 
1853 	mtx_lock(&vmmaplock);
1854 	LIST_FOREACH(vmmap, &vmmaphead[VM_HASH(addr)], vm_next)
1855 		if (vmmap->vm_addr == addr)
1856 			break;
1857 	if (vmmap)
1858 		LIST_REMOVE(vmmap, vm_next);
1859 	mtx_unlock(&vmmaplock);
1860 
1861 	return (vmmap);
1862 }
1863 
1864 #if defined(__i386__) || defined(__amd64__) || defined(__powerpc__) || defined(__aarch64__) || defined(__riscv)
1865 void *
_ioremap_attr(vm_paddr_t phys_addr,unsigned long size,int attr)1866 _ioremap_attr(vm_paddr_t phys_addr, unsigned long size, int attr)
1867 {
1868 	void *addr;
1869 
1870 	addr = pmap_mapdev_attr(phys_addr, size, attr);
1871 	if (addr == NULL)
1872 		return (NULL);
1873 	vmmap_add(addr, size);
1874 
1875 	return (addr);
1876 }
1877 #endif
1878 
1879 void
iounmap(void * addr)1880 iounmap(void *addr)
1881 {
1882 	struct vmmap *vmmap;
1883 
1884 	vmmap = vmmap_remove(addr);
1885 	if (vmmap == NULL)
1886 		return;
1887 #if defined(__i386__) || defined(__amd64__) || defined(__powerpc__) || defined(__aarch64__) || defined(__riscv)
1888 	pmap_unmapdev(addr, vmmap->vm_size);
1889 #endif
1890 	kfree(vmmap);
1891 }
1892 
1893 void *
vmap(struct page ** pages,unsigned int count,unsigned long flags,int prot)1894 vmap(struct page **pages, unsigned int count, unsigned long flags, int prot)
1895 {
1896 	vm_offset_t off;
1897 	size_t size;
1898 
1899 	size = count * PAGE_SIZE;
1900 	off = kva_alloc(size);
1901 	if (off == 0)
1902 		return (NULL);
1903 	vmmap_add((void *)off, size);
1904 	pmap_qenter(off, pages, count);
1905 
1906 	return ((void *)off);
1907 }
1908 
1909 void
vunmap(void * addr)1910 vunmap(void *addr)
1911 {
1912 	struct vmmap *vmmap;
1913 
1914 	vmmap = vmmap_remove(addr);
1915 	if (vmmap == NULL)
1916 		return;
1917 	pmap_qremove((vm_offset_t)addr, vmmap->vm_size / PAGE_SIZE);
1918 	kva_free((vm_offset_t)addr, vmmap->vm_size);
1919 	kfree(vmmap);
1920 }
1921 
1922 static char *
devm_kvasprintf(struct device * dev,gfp_t gfp,const char * fmt,va_list ap)1923 devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt, va_list ap)
1924 {
1925 	unsigned int len;
1926 	char *p;
1927 	va_list aq;
1928 
1929 	va_copy(aq, ap);
1930 	len = vsnprintf(NULL, 0, fmt, aq);
1931 	va_end(aq);
1932 
1933 	if (dev != NULL)
1934 		p = devm_kmalloc(dev, len + 1, gfp);
1935 	else
1936 		p = kmalloc(len + 1, gfp);
1937 	if (p != NULL)
1938 		vsnprintf(p, len + 1, fmt, ap);
1939 
1940 	return (p);
1941 }
1942 
1943 char *
kvasprintf(gfp_t gfp,const char * fmt,va_list ap)1944 kvasprintf(gfp_t gfp, const char *fmt, va_list ap)
1945 {
1946 
1947 	return (devm_kvasprintf(NULL, gfp, fmt, ap));
1948 }
1949 
1950 char *
lkpi_devm_kasprintf(struct device * dev,gfp_t gfp,const char * fmt,...)1951 lkpi_devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...)
1952 {
1953 	va_list ap;
1954 	char *p;
1955 
1956 	va_start(ap, fmt);
1957 	p = devm_kvasprintf(dev, gfp, fmt, ap);
1958 	va_end(ap);
1959 
1960 	return (p);
1961 }
1962 
1963 char *
kasprintf(gfp_t gfp,const char * fmt,...)1964 kasprintf(gfp_t gfp, const char *fmt, ...)
1965 {
1966 	va_list ap;
1967 	char *p;
1968 
1969 	va_start(ap, fmt);
1970 	p = kvasprintf(gfp, fmt, ap);
1971 	va_end(ap);
1972 
1973 	return (p);
1974 }
1975 
1976 int
__lkpi_hexdump_printf(void * arg1 __unused,const char * fmt,...)1977 __lkpi_hexdump_printf(void *arg1 __unused, const char *fmt, ...)
1978 {
1979 	va_list ap;
1980 	int result;
1981 
1982 	va_start(ap, fmt);
1983 	result = vprintf(fmt, ap);
1984 	va_end(ap);
1985 	return (result);
1986 }
1987 
1988 int
__lkpi_hexdump_sbuf_printf(void * arg1,const char * fmt,...)1989 __lkpi_hexdump_sbuf_printf(void *arg1, const char *fmt, ...)
1990 {
1991 	va_list ap;
1992 	int result;
1993 
1994 	va_start(ap, fmt);
1995 	result = sbuf_vprintf(arg1, fmt, ap);
1996 	va_end(ap);
1997 	return (result);
1998 }
1999 
2000 void
lkpi_hex_dump(int (* _fpf)(void *,const char *,...),void * arg1,const char * level,const char * prefix_str,const int prefix_type,const int rowsize,const int groupsize,const void * buf,size_t len,const bool ascii)2001 lkpi_hex_dump(int(*_fpf)(void *, const char *, ...), void *arg1,
2002     const char *level, const char *prefix_str,
2003     const int prefix_type, const int rowsize, const int groupsize,
2004     const void *buf, size_t len, const bool ascii)
2005 {
2006 	typedef const struct { long long value; } __packed *print_64p_t;
2007 	typedef const struct { uint32_t value; } __packed *print_32p_t;
2008 	typedef const struct { uint16_t value; } __packed *print_16p_t;
2009 	const void *buf_old = buf;
2010 	int row;
2011 
2012 	while (len > 0) {
2013 		if (level != NULL)
2014 			_fpf(arg1, "%s", level);
2015 		if (prefix_str != NULL)
2016 			_fpf(arg1, "%s ", prefix_str);
2017 
2018 		switch (prefix_type) {
2019 		case DUMP_PREFIX_ADDRESS:
2020 			_fpf(arg1, "[%p] ", buf);
2021 			break;
2022 		case DUMP_PREFIX_OFFSET:
2023 			_fpf(arg1, "[%#tx] ", ((const char *)buf -
2024 			    (const char *)buf_old));
2025 			break;
2026 		default:
2027 			break;
2028 		}
2029 		for (row = 0; row != rowsize; row++) {
2030 			if (groupsize == 8 && len > 7) {
2031 				_fpf(arg1, "%016llx ", ((print_64p_t)buf)->value);
2032 				buf = (const uint8_t *)buf + 8;
2033 				len -= 8;
2034 			} else if (groupsize == 4 && len > 3) {
2035 				_fpf(arg1, "%08x ", ((print_32p_t)buf)->value);
2036 				buf = (const uint8_t *)buf + 4;
2037 				len -= 4;
2038 			} else if (groupsize == 2 && len > 1) {
2039 				_fpf(arg1, "%04x ", ((print_16p_t)buf)->value);
2040 				buf = (const uint8_t *)buf + 2;
2041 				len -= 2;
2042 			} else if (len > 0) {
2043 				_fpf(arg1, "%02x ", *(const uint8_t *)buf);
2044 				buf = (const uint8_t *)buf + 1;
2045 				len--;
2046 			} else {
2047 				break;
2048 			}
2049 		}
2050 		_fpf(arg1, "\n");
2051 	}
2052 }
2053 
2054 static void
linux_timer_callback_wrapper(void * context)2055 linux_timer_callback_wrapper(void *context)
2056 {
2057 	struct timer_list *timer;
2058 
2059 	timer = context;
2060 
2061 	/* the timer is about to be shutdown permanently */
2062 	if (timer->function == NULL)
2063 		return;
2064 
2065 	if (linux_set_current_flags(curthread, M_NOWAIT)) {
2066 		/* try again later */
2067 		callout_reset(&timer->callout, 1,
2068 		    &linux_timer_callback_wrapper, timer);
2069 		return;
2070 	}
2071 
2072 	timer->function(timer->data);
2073 }
2074 
2075 static int
linux_timer_jiffies_until(unsigned long expires)2076 linux_timer_jiffies_until(unsigned long expires)
2077 {
2078 	unsigned long delta = expires - jiffies;
2079 
2080 	/*
2081 	 * Guard against already expired values and make sure that the value can
2082 	 * be used as a tick count, rather than a jiffies count.
2083 	 */
2084 	if ((long)delta < 1)
2085 		delta = 1;
2086 	else if (delta > INT_MAX)
2087 		delta = INT_MAX;
2088 	return ((int)delta);
2089 }
2090 
2091 int
mod_timer(struct timer_list * timer,unsigned long expires)2092 mod_timer(struct timer_list *timer, unsigned long expires)
2093 {
2094 	int ret;
2095 
2096 	timer->expires = expires;
2097 	ret = callout_reset(&timer->callout,
2098 	    linux_timer_jiffies_until(expires),
2099 	    &linux_timer_callback_wrapper, timer);
2100 
2101 	MPASS(ret == 0 || ret == 1);
2102 
2103 	return (ret == 1);
2104 }
2105 
2106 void
add_timer(struct timer_list * timer)2107 add_timer(struct timer_list *timer)
2108 {
2109 
2110 	callout_reset(&timer->callout,
2111 	    linux_timer_jiffies_until(timer->expires),
2112 	    &linux_timer_callback_wrapper, timer);
2113 }
2114 
2115 void
add_timer_on(struct timer_list * timer,int cpu)2116 add_timer_on(struct timer_list *timer, int cpu)
2117 {
2118 
2119 	callout_reset_on(&timer->callout,
2120 	    linux_timer_jiffies_until(timer->expires),
2121 	    &linux_timer_callback_wrapper, timer, cpu);
2122 }
2123 
2124 int
timer_delete(struct timer_list * timer)2125 timer_delete(struct timer_list *timer)
2126 {
2127 
2128 	if (callout_stop(&(timer)->callout) == -1)
2129 		return (0);
2130 	return (1);
2131 }
2132 
2133 int
timer_delete_sync(struct timer_list * timer)2134 timer_delete_sync(struct timer_list *timer)
2135 {
2136 
2137 	if (callout_drain(&(timer)->callout) == -1)
2138 		return (0);
2139 	return (1);
2140 }
2141 
2142 int
timer_shutdown_sync(struct timer_list * timer)2143 timer_shutdown_sync(struct timer_list *timer)
2144 {
2145 
2146 	timer->function = NULL;
2147 	return (del_timer_sync(timer));
2148 }
2149 
2150 /* greatest common divisor, Euclid equation */
2151 static uint64_t
lkpi_gcd_64(uint64_t a,uint64_t b)2152 lkpi_gcd_64(uint64_t a, uint64_t b)
2153 {
2154 	uint64_t an;
2155 	uint64_t bn;
2156 
2157 	while (b != 0) {
2158 		an = b;
2159 		bn = a % b;
2160 		a = an;
2161 		b = bn;
2162 	}
2163 	return (a);
2164 }
2165 
2166 uint64_t lkpi_nsec2hz_rem;
2167 uint64_t lkpi_nsec2hz_div = 1000000000ULL;
2168 uint64_t lkpi_nsec2hz_max;
2169 
2170 uint64_t lkpi_usec2hz_rem;
2171 uint64_t lkpi_usec2hz_div = 1000000ULL;
2172 uint64_t lkpi_usec2hz_max;
2173 
2174 uint64_t lkpi_msec2hz_rem;
2175 uint64_t lkpi_msec2hz_div = 1000ULL;
2176 uint64_t lkpi_msec2hz_max;
2177 
2178 static void
linux_timer_init(void * arg)2179 linux_timer_init(void *arg)
2180 {
2181 	uint64_t gcd;
2182 
2183 	/*
2184 	 * Compute an internal HZ value which can divide 2**32 to
2185 	 * avoid timer rounding problems when the tick value wraps
2186 	 * around 2**32:
2187 	 */
2188 	linux_timer_hz_mask = 1;
2189 	while (linux_timer_hz_mask < (unsigned long)hz)
2190 		linux_timer_hz_mask *= 2;
2191 	linux_timer_hz_mask--;
2192 
2193 	/* compute some internal constants */
2194 
2195 	lkpi_nsec2hz_rem = hz;
2196 	lkpi_usec2hz_rem = hz;
2197 	lkpi_msec2hz_rem = hz;
2198 
2199 	gcd = lkpi_gcd_64(lkpi_nsec2hz_rem, lkpi_nsec2hz_div);
2200 	lkpi_nsec2hz_rem /= gcd;
2201 	lkpi_nsec2hz_div /= gcd;
2202 	lkpi_nsec2hz_max = -1ULL / lkpi_nsec2hz_rem;
2203 
2204 	gcd = lkpi_gcd_64(lkpi_usec2hz_rem, lkpi_usec2hz_div);
2205 	lkpi_usec2hz_rem /= gcd;
2206 	lkpi_usec2hz_div /= gcd;
2207 	lkpi_usec2hz_max = -1ULL / lkpi_usec2hz_rem;
2208 
2209 	gcd = lkpi_gcd_64(lkpi_msec2hz_rem, lkpi_msec2hz_div);
2210 	lkpi_msec2hz_rem /= gcd;
2211 	lkpi_msec2hz_div /= gcd;
2212 	lkpi_msec2hz_max = -1ULL / lkpi_msec2hz_rem;
2213 }
2214 SYSINIT(linux_timer, SI_SUB_DRIVERS, SI_ORDER_FIRST, linux_timer_init, NULL);
2215 
2216 void
linux_complete_common(struct completion * c,int all)2217 linux_complete_common(struct completion *c, int all)
2218 {
2219 	sleepq_lock(c);
2220 	if (all) {
2221 		c->done = UINT_MAX;
2222 		sleepq_broadcast(c, SLEEPQ_SLEEP, 0, 0);
2223 	} else {
2224 		if (c->done != UINT_MAX)
2225 			c->done++;
2226 		sleepq_signal(c, SLEEPQ_SLEEP, 0, 0);
2227 	}
2228 	sleepq_release(c);
2229 }
2230 
2231 /*
2232  * Indefinite wait for done != 0 with or without signals.
2233  */
2234 int
linux_wait_for_common(struct completion * c,int flags)2235 linux_wait_for_common(struct completion *c, int flags)
2236 {
2237 	struct task_struct *task;
2238 	int error;
2239 
2240 	if (SCHEDULER_STOPPED())
2241 		return (0);
2242 
2243 	task = current;
2244 
2245 	if (flags != 0)
2246 		flags = SLEEPQ_INTERRUPTIBLE | SLEEPQ_SLEEP;
2247 	else
2248 		flags = SLEEPQ_SLEEP;
2249 	error = 0;
2250 	for (;;) {
2251 		sleepq_lock(c);
2252 		if (c->done)
2253 			break;
2254 		sleepq_add(c, NULL, "completion", flags, 0);
2255 		if (flags & SLEEPQ_INTERRUPTIBLE) {
2256 			DROP_GIANT();
2257 			error = -sleepq_wait_sig(c, 0);
2258 			PICKUP_GIANT();
2259 			if (error != 0) {
2260 				linux_schedule_save_interrupt_value(task, error);
2261 				error = -ERESTARTSYS;
2262 				goto intr;
2263 			}
2264 		} else {
2265 			DROP_GIANT();
2266 			sleepq_wait(c, 0);
2267 			PICKUP_GIANT();
2268 		}
2269 	}
2270 	if (c->done != UINT_MAX)
2271 		c->done--;
2272 	sleepq_release(c);
2273 
2274 intr:
2275 	return (error);
2276 }
2277 
2278 /*
2279  * Time limited wait for done != 0 with or without signals.
2280  */
2281 unsigned long
linux_wait_for_timeout_common(struct completion * c,unsigned long timeout,int flags)2282 linux_wait_for_timeout_common(struct completion *c, unsigned long timeout,
2283     int flags)
2284 {
2285 	struct task_struct *task;
2286 	unsigned long end = jiffies + timeout, error;
2287 
2288 	if (SCHEDULER_STOPPED())
2289 		return (0);
2290 
2291 	task = current;
2292 
2293 	if (flags != 0)
2294 		flags = SLEEPQ_INTERRUPTIBLE | SLEEPQ_SLEEP;
2295 	else
2296 		flags = SLEEPQ_SLEEP;
2297 
2298 	for (;;) {
2299 		sleepq_lock(c);
2300 		if (c->done)
2301 			break;
2302 		sleepq_add(c, NULL, "completion", flags, 0);
2303 		sleepq_set_timeout(c, linux_timer_jiffies_until(end));
2304 
2305 		DROP_GIANT();
2306 		if (flags & SLEEPQ_INTERRUPTIBLE)
2307 			error = -sleepq_timedwait_sig(c, 0);
2308 		else
2309 			error = -sleepq_timedwait(c, 0);
2310 		PICKUP_GIANT();
2311 
2312 		if (error != 0) {
2313 			/* check for timeout */
2314 			if (error == -EWOULDBLOCK) {
2315 				error = 0;	/* timeout */
2316 			} else {
2317 				/* signal happened */
2318 				linux_schedule_save_interrupt_value(task, error);
2319 				error = -ERESTARTSYS;
2320 			}
2321 			goto done;
2322 		}
2323 	}
2324 	if (c->done != UINT_MAX)
2325 		c->done--;
2326 	sleepq_release(c);
2327 
2328 	/* return how many jiffies are left */
2329 	error = linux_timer_jiffies_until(end);
2330 done:
2331 	return (error);
2332 }
2333 
2334 int
linux_try_wait_for_completion(struct completion * c)2335 linux_try_wait_for_completion(struct completion *c)
2336 {
2337 	int isdone;
2338 
2339 	sleepq_lock(c);
2340 	isdone = (c->done != 0);
2341 	if (c->done != 0 && c->done != UINT_MAX)
2342 		c->done--;
2343 	sleepq_release(c);
2344 	return (isdone);
2345 }
2346 
2347 int
linux_completion_done(struct completion * c)2348 linux_completion_done(struct completion *c)
2349 {
2350 	int isdone;
2351 
2352 	sleepq_lock(c);
2353 	isdone = (c->done != 0);
2354 	sleepq_release(c);
2355 	return (isdone);
2356 }
2357 
2358 static void
linux_cdev_deref(struct linux_cdev * ldev)2359 linux_cdev_deref(struct linux_cdev *ldev)
2360 {
2361 	if (refcount_release(&ldev->refs) &&
2362 	    ldev->kobj.ktype == &linux_cdev_ktype)
2363 		kfree(ldev);
2364 }
2365 
2366 static void
linux_cdev_release(struct kobject * kobj)2367 linux_cdev_release(struct kobject *kobj)
2368 {
2369 	struct linux_cdev *cdev;
2370 	struct kobject *parent;
2371 
2372 	cdev = container_of(kobj, struct linux_cdev, kobj);
2373 	parent = kobj->parent;
2374 	linux_destroy_dev(cdev);
2375 	linux_cdev_deref(cdev);
2376 	kobject_put(parent);
2377 }
2378 
2379 static void
linux_cdev_static_release(struct kobject * kobj)2380 linux_cdev_static_release(struct kobject *kobj)
2381 {
2382 	struct cdev *cdev;
2383 	struct linux_cdev *ldev;
2384 
2385 	ldev = container_of(kobj, struct linux_cdev, kobj);
2386 	cdev = ldev->cdev;
2387 	if (cdev != NULL) {
2388 		destroy_dev(cdev);
2389 		ldev->cdev = NULL;
2390 	}
2391 	kobject_put(kobj->parent);
2392 }
2393 
2394 int
linux_cdev_device_add(struct linux_cdev * ldev,struct device * dev)2395 linux_cdev_device_add(struct linux_cdev *ldev, struct device *dev)
2396 {
2397 	int ret;
2398 
2399 	if (dev->devt != 0) {
2400 		/* Set parent kernel object. */
2401 		ldev->kobj.parent = &dev->kobj;
2402 
2403 		/*
2404 		 * Unlike Linux we require the kobject of the
2405 		 * character device structure to have a valid name
2406 		 * before calling this function:
2407 		 */
2408 		if (ldev->kobj.name == NULL)
2409 			return (-EINVAL);
2410 
2411 		ret = cdev_add(ldev, dev->devt, 1);
2412 		if (ret)
2413 			return (ret);
2414 	}
2415 	ret = device_add(dev);
2416 	if (ret != 0 && dev->devt != 0)
2417 		cdev_del(ldev);
2418 	return (ret);
2419 }
2420 
2421 void
linux_cdev_device_del(struct linux_cdev * ldev,struct device * dev)2422 linux_cdev_device_del(struct linux_cdev *ldev, struct device *dev)
2423 {
2424 	device_del(dev);
2425 
2426 	if (dev->devt != 0)
2427 		cdev_del(ldev);
2428 }
2429 
2430 static void
linux_destroy_dev(struct linux_cdev * ldev)2431 linux_destroy_dev(struct linux_cdev *ldev)
2432 {
2433 
2434 	if (ldev->cdev == NULL)
2435 		return;
2436 
2437 	MPASS((ldev->siref & LDEV_SI_DTR) == 0);
2438 	MPASS(ldev->kobj.ktype == &linux_cdev_ktype);
2439 
2440 	atomic_set_int(&ldev->siref, LDEV_SI_DTR);
2441 	while ((atomic_load_int(&ldev->siref) & ~LDEV_SI_DTR) != 0)
2442 		pause("ldevdtr", hz / 4);
2443 
2444 	destroy_dev(ldev->cdev);
2445 	ldev->cdev = NULL;
2446 }
2447 
2448 const struct kobj_type linux_cdev_ktype = {
2449 	.release = linux_cdev_release,
2450 };
2451 
2452 const struct kobj_type linux_cdev_static_ktype = {
2453 	.release = linux_cdev_static_release,
2454 };
2455 
2456 static void
linux_handle_ifnet_link_event(void * arg,struct ifnet * ifp,int linkstate)2457 linux_handle_ifnet_link_event(void *arg, struct ifnet *ifp, int linkstate)
2458 {
2459 	struct notifier_block *nb;
2460 	struct netdev_notifier_info ni;
2461 
2462 	nb = arg;
2463 	ni.ifp = ifp;
2464 	ni.dev = (struct net_device *)ifp;
2465 	if (linkstate == LINK_STATE_UP)
2466 		nb->notifier_call(nb, NETDEV_UP, &ni);
2467 	else
2468 		nb->notifier_call(nb, NETDEV_DOWN, &ni);
2469 }
2470 
2471 static void
linux_handle_ifnet_arrival_event(void * arg,struct ifnet * ifp)2472 linux_handle_ifnet_arrival_event(void *arg, struct ifnet *ifp)
2473 {
2474 	struct notifier_block *nb;
2475 	struct netdev_notifier_info ni;
2476 
2477 	nb = arg;
2478 	ni.ifp = ifp;
2479 	ni.dev = (struct net_device *)ifp;
2480 	nb->notifier_call(nb, NETDEV_REGISTER, &ni);
2481 }
2482 
2483 static void
linux_handle_ifnet_departure_event(void * arg,struct ifnet * ifp)2484 linux_handle_ifnet_departure_event(void *arg, struct ifnet *ifp)
2485 {
2486 	struct notifier_block *nb;
2487 	struct netdev_notifier_info ni;
2488 
2489 	nb = arg;
2490 	ni.ifp = ifp;
2491 	ni.dev = (struct net_device *)ifp;
2492 	nb->notifier_call(nb, NETDEV_UNREGISTER, &ni);
2493 }
2494 
2495 static void
linux_handle_iflladdr_event(void * arg,struct ifnet * ifp)2496 linux_handle_iflladdr_event(void *arg, struct ifnet *ifp)
2497 {
2498 	struct notifier_block *nb;
2499 	struct netdev_notifier_info ni;
2500 
2501 	nb = arg;
2502 	ni.ifp = ifp;
2503 	ni.dev = (struct net_device *)ifp;
2504 	nb->notifier_call(nb, NETDEV_CHANGEADDR, &ni);
2505 }
2506 
2507 static void
linux_handle_ifaddr_event(void * arg,struct ifnet * ifp)2508 linux_handle_ifaddr_event(void *arg, struct ifnet *ifp)
2509 {
2510 	struct notifier_block *nb;
2511 	struct netdev_notifier_info ni;
2512 
2513 	nb = arg;
2514 	ni.ifp = ifp;
2515 	ni.dev = (struct net_device *)ifp;
2516 	nb->notifier_call(nb, NETDEV_CHANGEIFADDR, &ni);
2517 }
2518 
2519 int
register_netdevice_notifier(struct notifier_block * nb)2520 register_netdevice_notifier(struct notifier_block *nb)
2521 {
2522 
2523 	nb->tags[NETDEV_UP] = EVENTHANDLER_REGISTER(
2524 	    ifnet_link_event, linux_handle_ifnet_link_event, nb, 0);
2525 	nb->tags[NETDEV_REGISTER] = EVENTHANDLER_REGISTER(
2526 	    ifnet_arrival_event, linux_handle_ifnet_arrival_event, nb, 0);
2527 	nb->tags[NETDEV_UNREGISTER] = EVENTHANDLER_REGISTER(
2528 	    ifnet_departure_event, linux_handle_ifnet_departure_event, nb, 0);
2529 	nb->tags[NETDEV_CHANGEADDR] = EVENTHANDLER_REGISTER(
2530 	    iflladdr_event, linux_handle_iflladdr_event, nb, 0);
2531 
2532 	return (0);
2533 }
2534 
2535 int
register_inetaddr_notifier(struct notifier_block * nb)2536 register_inetaddr_notifier(struct notifier_block *nb)
2537 {
2538 
2539 	nb->tags[NETDEV_CHANGEIFADDR] = EVENTHANDLER_REGISTER(
2540 	    ifaddr_event, linux_handle_ifaddr_event, nb, 0);
2541 	return (0);
2542 }
2543 
2544 int
unregister_netdevice_notifier(struct notifier_block * nb)2545 unregister_netdevice_notifier(struct notifier_block *nb)
2546 {
2547 
2548 	EVENTHANDLER_DEREGISTER(ifnet_link_event,
2549 	    nb->tags[NETDEV_UP]);
2550 	EVENTHANDLER_DEREGISTER(ifnet_arrival_event,
2551 	    nb->tags[NETDEV_REGISTER]);
2552 	EVENTHANDLER_DEREGISTER(ifnet_departure_event,
2553 	    nb->tags[NETDEV_UNREGISTER]);
2554 	EVENTHANDLER_DEREGISTER(iflladdr_event,
2555 	    nb->tags[NETDEV_CHANGEADDR]);
2556 
2557 	return (0);
2558 }
2559 
2560 int
unregister_inetaddr_notifier(struct notifier_block * nb)2561 unregister_inetaddr_notifier(struct notifier_block *nb)
2562 {
2563 
2564 	EVENTHANDLER_DEREGISTER(ifaddr_event,
2565 	    nb->tags[NETDEV_CHANGEIFADDR]);
2566 
2567 	return (0);
2568 }
2569 
2570 struct list_sort_thunk {
2571 	int (*cmp)(void *, struct list_head *, struct list_head *);
2572 	void *priv;
2573 };
2574 
2575 static inline int
linux_le_cmp(const void * d1,const void * d2,void * priv)2576 linux_le_cmp(const void *d1, const void *d2, void *priv)
2577 {
2578 	struct list_head *le1, *le2;
2579 	struct list_sort_thunk *thunk;
2580 
2581 	thunk = priv;
2582 	le1 = *(__DECONST(struct list_head **, d1));
2583 	le2 = *(__DECONST(struct list_head **, d2));
2584 	return ((thunk->cmp)(thunk->priv, le1, le2));
2585 }
2586 
2587 void
list_sort(void * priv,struct list_head * head,int (* cmp)(void * priv,struct list_head * a,struct list_head * b))2588 list_sort(void *priv, struct list_head *head, int (*cmp)(void *priv,
2589     struct list_head *a, struct list_head *b))
2590 {
2591 	struct list_sort_thunk thunk;
2592 	struct list_head **ar, *le;
2593 	size_t count, i;
2594 
2595 	count = 0;
2596 	list_for_each(le, head)
2597 		count++;
2598 	ar = malloc(sizeof(struct list_head *) * count, M_KMALLOC, M_WAITOK);
2599 	i = 0;
2600 	list_for_each(le, head)
2601 		ar[i++] = le;
2602 	thunk.cmp = cmp;
2603 	thunk.priv = priv;
2604 	qsort_r(ar, count, sizeof(struct list_head *), linux_le_cmp, &thunk);
2605 	INIT_LIST_HEAD(head);
2606 	for (i = 0; i < count; i++)
2607 		list_add_tail(ar[i], head);
2608 	free(ar, M_KMALLOC);
2609 }
2610 
2611 #if defined(__i386__) || defined(__amd64__)
2612 int
linux_wbinvd_on_all_cpus(void)2613 linux_wbinvd_on_all_cpus(void)
2614 {
2615 
2616 	pmap_invalidate_cache();
2617 	return (0);
2618 }
2619 #endif
2620 
2621 int
linux_on_each_cpu(void callback (void *),void * data)2622 linux_on_each_cpu(void callback(void *), void *data)
2623 {
2624 
2625 	smp_rendezvous(smp_no_rendezvous_barrier, callback,
2626 	    smp_no_rendezvous_barrier, data);
2627 	return (0);
2628 }
2629 
2630 int
linux_in_atomic(void)2631 linux_in_atomic(void)
2632 {
2633 
2634 	return ((curthread->td_pflags & TDP_NOFAULTING) != 0);
2635 }
2636 
2637 struct linux_cdev *
linux_find_cdev(const char * name,unsigned major,unsigned minor)2638 linux_find_cdev(const char *name, unsigned major, unsigned minor)
2639 {
2640 	dev_t dev = MKDEV(major, minor);
2641 	struct cdev *cdev;
2642 
2643 	dev_lock();
2644 	LIST_FOREACH(cdev, &linuxcdevsw.d_devs, si_list) {
2645 		struct linux_cdev *ldev = cdev->si_drv1;
2646 		if (ldev->dev == dev &&
2647 		    strcmp(kobject_name(&ldev->kobj), name) == 0) {
2648 			break;
2649 		}
2650 	}
2651 	dev_unlock();
2652 
2653 	return (cdev != NULL ? cdev->si_drv1 : NULL);
2654 }
2655 
2656 int
__register_chrdev(unsigned int major,unsigned int baseminor,unsigned int count,const char * name,const struct file_operations * fops)2657 __register_chrdev(unsigned int major, unsigned int baseminor,
2658     unsigned int count, const char *name,
2659     const struct file_operations *fops)
2660 {
2661 	struct linux_cdev *cdev;
2662 	int ret = 0;
2663 	int i;
2664 
2665 	for (i = baseminor; i < baseminor + count; i++) {
2666 		cdev = cdev_alloc();
2667 		cdev->ops = fops;
2668 		kobject_set_name(&cdev->kobj, name);
2669 
2670 		ret = cdev_add(cdev, makedev(major, i), 1);
2671 		if (ret != 0)
2672 			break;
2673 	}
2674 	return (ret);
2675 }
2676 
2677 int
__register_chrdev_p(unsigned int major,unsigned int baseminor,unsigned int count,const char * name,const struct file_operations * fops,uid_t uid,gid_t gid,int mode)2678 __register_chrdev_p(unsigned int major, unsigned int baseminor,
2679     unsigned int count, const char *name,
2680     const struct file_operations *fops, uid_t uid,
2681     gid_t gid, int mode)
2682 {
2683 	struct linux_cdev *cdev;
2684 	int ret = 0;
2685 	int i;
2686 
2687 	for (i = baseminor; i < baseminor + count; i++) {
2688 		cdev = cdev_alloc();
2689 		cdev->ops = fops;
2690 		kobject_set_name(&cdev->kobj, name);
2691 
2692 		ret = cdev_add_ext(cdev, makedev(major, i), uid, gid, mode);
2693 		if (ret != 0)
2694 			break;
2695 	}
2696 	return (ret);
2697 }
2698 
2699 void
__unregister_chrdev(unsigned int major,unsigned int baseminor,unsigned int count,const char * name)2700 __unregister_chrdev(unsigned int major, unsigned int baseminor,
2701     unsigned int count, const char *name)
2702 {
2703 	struct linux_cdev *cdevp;
2704 	int i;
2705 
2706 	for (i = baseminor; i < baseminor + count; i++) {
2707 		cdevp = linux_find_cdev(name, major, i);
2708 		if (cdevp != NULL)
2709 			cdev_del(cdevp);
2710 	}
2711 }
2712 
2713 void
linux_dump_stack(void)2714 linux_dump_stack(void)
2715 {
2716 #ifdef STACK
2717 	struct stack st;
2718 
2719 	stack_save(&st);
2720 	stack_print(&st);
2721 #endif
2722 }
2723 
2724 int
linuxkpi_net_ratelimit(void)2725 linuxkpi_net_ratelimit(void)
2726 {
2727 
2728 	return (ppsratecheck(&lkpi_net_lastlog, &lkpi_net_curpps,
2729 	   lkpi_net_maxpps));
2730 }
2731 
2732 struct io_mapping *
io_mapping_create_wc(resource_size_t base,unsigned long size)2733 io_mapping_create_wc(resource_size_t base, unsigned long size)
2734 {
2735 	struct io_mapping *mapping;
2736 
2737 	mapping = kmalloc(sizeof(*mapping), GFP_KERNEL);
2738 	if (mapping == NULL)
2739 		return (NULL);
2740 	return (io_mapping_init_wc(mapping, base, size));
2741 }
2742 
2743 /* We likely want a linuxkpi_device.c at some point. */
2744 bool
device_can_wakeup(struct device * dev)2745 device_can_wakeup(struct device *dev)
2746 {
2747 
2748 	if (dev == NULL)
2749 		return (false);
2750 	/*
2751 	 * XXX-BZ iwlwifi queries it as part of enabling WoWLAN.
2752 	 * Normally this would be based on a bool in dev->power.XXX.
2753 	 * Check such as PCI PCIM_PCAP_*PME.  We have no way to enable this yet.
2754 	 * We may get away by directly calling into bsddev for as long as
2755 	 * we can assume PCI only avoiding changing struct device breaking KBI.
2756 	 */
2757 	pr_debug("%s:%d: not enabled; see comment.\n", __func__, __LINE__);
2758 	return (false);
2759 }
2760 
2761 static void
devm_device_group_remove(struct device * dev,void * p)2762 devm_device_group_remove(struct device *dev, void *p)
2763 {
2764 	const struct attribute_group **dr = p;
2765 	const struct attribute_group *group = *dr;
2766 
2767 	sysfs_remove_group(&dev->kobj, group);
2768 }
2769 
2770 int
lkpi_devm_device_add_group(struct device * dev,const struct attribute_group * group)2771 lkpi_devm_device_add_group(struct device *dev,
2772     const struct attribute_group *group)
2773 {
2774 	const struct attribute_group **dr;
2775 	int ret;
2776 
2777 	dr = devres_alloc(devm_device_group_remove, sizeof(*dr), GFP_KERNEL);
2778 	if (dr == NULL)
2779 		return (-ENOMEM);
2780 
2781 	ret = sysfs_create_group(&dev->kobj, group);
2782 	if (ret == 0) {
2783 		*dr = group;
2784 		devres_add(dev, dr);
2785 	} else
2786 		devres_free(dr);
2787 
2788 	return (ret);
2789 }
2790 
2791 #if defined(__i386__) || defined(__amd64__)
2792 bool linux_cpu_has_clflush;
2793 struct cpuinfo_x86 boot_cpu_data;
2794 struct cpuinfo_x86 *__cpu_data;
2795 #endif
2796 
2797 cpumask_t *
lkpi_get_static_single_cpu_mask(int cpuid)2798 lkpi_get_static_single_cpu_mask(int cpuid)
2799 {
2800 
2801 	KASSERT((cpuid >= 0 && cpuid <= mp_maxid), ("%s: invalid cpuid %d\n",
2802 	    __func__, cpuid));
2803 	KASSERT(!CPU_ABSENT(cpuid), ("%s: cpu with cpuid %d is absent\n",
2804 	    __func__, cpuid));
2805 
2806 	return (static_single_cpu_mask[cpuid]);
2807 }
2808 
2809 bool
lkpi_xen_initial_domain(void)2810 lkpi_xen_initial_domain(void)
2811 {
2812 #ifdef XENHVM
2813 	return (xen_initial_domain());
2814 #else
2815 	return (false);
2816 #endif
2817 }
2818 
2819 bool
lkpi_xen_pv_domain(void)2820 lkpi_xen_pv_domain(void)
2821 {
2822 #ifdef XENHVM
2823 	return (xen_pv_domain());
2824 #else
2825 	return (false);
2826 #endif
2827 }
2828 
2829 static void
linux_compat_init(void * arg)2830 linux_compat_init(void *arg)
2831 {
2832 	struct sysctl_oid *rootoid;
2833 	int i;
2834 
2835 #if defined(__i386__) || defined(__amd64__)
2836 	static const uint32_t x86_vendors[X86_VENDOR_NUM] = {
2837 		[X86_VENDOR_INTEL] = CPU_VENDOR_INTEL,
2838 		[X86_VENDOR_CYRIX] = CPU_VENDOR_CYRIX,
2839 		[X86_VENDOR_AMD] = CPU_VENDOR_AMD,
2840 		[X86_VENDOR_UMC] = CPU_VENDOR_UMC,
2841 		[X86_VENDOR_CENTAUR] = CPU_VENDOR_CENTAUR,
2842 		[X86_VENDOR_TRANSMETA] = CPU_VENDOR_TRANSMETA,
2843 		[X86_VENDOR_NSC] = CPU_VENDOR_NSC,
2844 		[X86_VENDOR_HYGON] = CPU_VENDOR_HYGON,
2845 	};
2846 	uint8_t x86_vendor = X86_VENDOR_UNKNOWN;
2847 
2848 	for (i = 0; i < X86_VENDOR_NUM; i++) {
2849 		if (cpu_vendor_id != 0 && cpu_vendor_id == x86_vendors[i]) {
2850 			x86_vendor = i;
2851 			break;
2852 		}
2853 	}
2854 	linux_cpu_has_clflush = (cpu_feature & CPUID_CLFSH);
2855 	boot_cpu_data.x86_clflush_size = cpu_clflush_line_size;
2856 	boot_cpu_data.x86_max_cores = mp_ncpus;
2857 	boot_cpu_data.x86 = CPUID_TO_FAMILY(cpu_id);
2858 	boot_cpu_data.x86_model = CPUID_TO_MODEL(cpu_id);
2859 	boot_cpu_data.x86_vendor = x86_vendor;
2860 
2861 	__cpu_data = kmalloc_array(mp_maxid + 1,
2862 	    sizeof(*__cpu_data), M_WAITOK | M_ZERO);
2863 	CPU_FOREACH(i) {
2864 		__cpu_data[i].x86_clflush_size = cpu_clflush_line_size;
2865 		__cpu_data[i].x86_max_cores = mp_ncpus;
2866 		__cpu_data[i].x86 = CPUID_TO_FAMILY(cpu_id);
2867 		__cpu_data[i].x86_model = CPUID_TO_MODEL(cpu_id);
2868 		__cpu_data[i].x86_vendor = x86_vendor;
2869 	}
2870 #endif
2871 	rw_init(&linux_vma_lock, "lkpi-vma-lock");
2872 
2873 	rootoid = SYSCTL_ADD_ROOT_NODE(NULL,
2874 	    OID_AUTO, "sys", CTLFLAG_RD|CTLFLAG_MPSAFE, NULL, "sys");
2875 	kobject_init(&linux_class_root, &linux_class_ktype);
2876 	kobject_set_name(&linux_class_root, "class");
2877 	linux_class_root.oidp = SYSCTL_ADD_NODE(NULL, SYSCTL_CHILDREN(rootoid),
2878 	    OID_AUTO, "class", CTLFLAG_RD|CTLFLAG_MPSAFE, NULL, "class");
2879 	kobject_init(&linux_root_device.kobj, &linux_dev_ktype);
2880 	kobject_set_name(&linux_root_device.kobj, "device");
2881 	linux_root_device.kobj.oidp = SYSCTL_ADD_NODE(NULL,
2882 	    SYSCTL_CHILDREN(rootoid), OID_AUTO, "device",
2883 	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "device");
2884 	linux_root_device.bsddev = root_bus;
2885 	linux_class_misc.name = "misc";
2886 	class_register(&linux_class_misc);
2887 	INIT_LIST_HEAD(&pci_drivers);
2888 	INIT_LIST_HEAD(&pci_devices);
2889 	spin_lock_init(&pci_lock);
2890 	mtx_init(&vmmaplock, "IO Map lock", NULL, MTX_DEF);
2891 	for (i = 0; i < VMMAP_HASH_SIZE; i++)
2892 		LIST_INIT(&vmmaphead[i]);
2893 	init_waitqueue_head(&linux_bit_waitq);
2894 	init_waitqueue_head(&linux_var_waitq);
2895 
2896 	CPU_COPY(&all_cpus, &cpu_online_mask);
2897 	/*
2898 	 * Generate a single-CPU cpumask_t for each CPU (possibly) in the system.
2899 	 * CPUs are indexed from 0..(mp_maxid).  The entry for cpuid 0 will only
2900 	 * have itself in the cpumask, cupid 1 only itself on entry 1, and so on.
2901 	 * This is used by cpumask_of() (and possibly others in the future) for,
2902 	 * e.g., drivers to pass hints to irq_set_affinity_hint().
2903 	 */
2904 	static_single_cpu_mask = kmalloc_array(mp_maxid + 1,
2905 	    sizeof(static_single_cpu_mask), M_WAITOK | M_ZERO);
2906 
2907 	/*
2908 	 * When the number of CPUs reach a threshold, we start to save memory
2909 	 * given the sets are static by overlapping those having their single
2910 	 * bit set at same position in a bitset word.  Asymptotically, this
2911 	 * regular scheme is in O(n²) whereas the overlapping one is in O(n)
2912 	 * only with n being the maximum number of CPUs, so the gain will become
2913 	 * huge quite quickly.  The threshold for 64-bit architectures is 128
2914 	 * CPUs.
2915 	 */
2916 	if (mp_ncpus < (2 * _BITSET_BITS)) {
2917 		cpumask_t *sscm_ptr;
2918 
2919 		/*
2920 		 * This represents 'mp_ncpus * __bitset_words(CPU_SETSIZE) *
2921 		 * (_BITSET_BITS / 8)' bytes (for comparison with the
2922 		 * overlapping scheme).
2923 		 */
2924 		static_single_cpu_mask_lcs = kmalloc_array(mp_ncpus,
2925 		    sizeof(*static_single_cpu_mask_lcs),
2926 		    M_WAITOK | M_ZERO);
2927 
2928 		sscm_ptr = static_single_cpu_mask_lcs;
2929 		CPU_FOREACH(i) {
2930 			static_single_cpu_mask[i] = sscm_ptr++;
2931 			CPU_SET(i, static_single_cpu_mask[i]);
2932 		}
2933 	} else {
2934 		/* Pointer to a bitset word. */
2935 		__typeof(((cpuset_t *)NULL)->__bits[0]) *bwp;
2936 
2937 		/*
2938 		 * Allocate memory for (static) spans of 'cpumask_t' ('cpuset_t'
2939 		 * really) with a single bit set that can be reused for all
2940 		 * single CPU masks by making them start at different offsets.
2941 		 * We need '__bitset_words(CPU_SETSIZE) - 1' bitset words before
2942 		 * the word having its single bit set, and the same amount
2943 		 * after.
2944 		 */
2945 		static_single_cpu_mask_lcs = mallocarray(_BITSET_BITS,
2946 		    (2 * __bitset_words(CPU_SETSIZE) - 1) * (_BITSET_BITS / 8),
2947 		    M_KMALLOC, M_WAITOK | M_ZERO);
2948 
2949 		/*
2950 		 * We rely below on cpuset_t and the bitset generic
2951 		 * implementation assigning words in the '__bits' array in the
2952 		 * same order of bits (i.e., little-endian ordering, not to be
2953 		 * confused with machine endianness, which concerns bits in
2954 		 * words and other integers).  This is an imperfect test, but it
2955 		 * will detect a change to big-endian ordering.
2956 		 */
2957 		_Static_assert(
2958 		    __bitset_word(_BITSET_BITS + 1, _BITSET_BITS) == 1,
2959 		    "Assumes a bitset implementation that is little-endian "
2960 		    "on its words");
2961 
2962 		/* Initialize the single bit of each static span. */
2963 		bwp = (__typeof(bwp))static_single_cpu_mask_lcs +
2964 		    (__bitset_words(CPU_SETSIZE) - 1);
2965 		for (i = 0; i < _BITSET_BITS; i++) {
2966 			CPU_SET(i, (cpuset_t *)bwp);
2967 			bwp += (2 * __bitset_words(CPU_SETSIZE) - 1);
2968 		}
2969 
2970 		/*
2971 		 * Finally set all CPU masks to the proper word in their
2972 		 * relevant span.
2973 		 */
2974 		CPU_FOREACH(i) {
2975 			bwp = (__typeof(bwp))static_single_cpu_mask_lcs;
2976 			/* Find the non-zero word of the relevant span. */
2977 			bwp += (2 * __bitset_words(CPU_SETSIZE) - 1) *
2978 			    (i % _BITSET_BITS) +
2979 			    __bitset_words(CPU_SETSIZE) - 1;
2980 			/* Shift to find the CPU mask start. */
2981 			bwp -= (i / _BITSET_BITS);
2982 			static_single_cpu_mask[i] = (cpuset_t *)bwp;
2983 		}
2984 	}
2985 
2986 	strlcpy(init_uts_ns.name.release, osrelease, sizeof(init_uts_ns.name.release));
2987 }
2988 SYSINIT(linux_compat, SI_SUB_DRIVERS, SI_ORDER_SECOND, linux_compat_init, NULL);
2989 
2990 static void
linux_compat_uninit(void * arg)2991 linux_compat_uninit(void *arg)
2992 {
2993 	linux_kobject_kfree_name(&linux_class_root);
2994 	linux_kobject_kfree_name(&linux_root_device.kobj);
2995 	linux_kobject_kfree_name(&linux_class_misc.kobj);
2996 
2997 	free(static_single_cpu_mask_lcs, M_KMALLOC);
2998 	free(static_single_cpu_mask, M_KMALLOC);
2999 #if defined(__i386__) || defined(__amd64__)
3000 	free(__cpu_data, M_KMALLOC);
3001 #endif
3002 
3003 	mtx_destroy(&vmmaplock);
3004 	spin_lock_destroy(&pci_lock);
3005 	rw_destroy(&linux_vma_lock);
3006 }
3007 SYSUNINIT(linux_compat, SI_SUB_DRIVERS, SI_ORDER_SECOND, linux_compat_uninit, NULL);
3008 
3009 /*
3010  * NOTE: Linux frequently uses "unsigned long" for pointer to integer
3011  * conversion and vice versa, where in FreeBSD "uintptr_t" would be
3012  * used. Assert these types have the same size, else some parts of the
3013  * LinuxKPI may not work like expected:
3014  */
3015 CTASSERT(sizeof(unsigned long) == sizeof(uintptr_t));
3016