xref: /freebsd/sys/compat/linuxkpi/common/src/linux_current.c (revision d93a896ef95946b0bf1219866fcb324b78543444)
1 /*-
2  * Copyright (c) 2017 Hans Petter Selasky
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice unmodified, this list of conditions, and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include <linux/compat.h>
31 #include <linux/completion.h>
32 #include <linux/mm.h>
33 #include <linux/kthread.h>
34 
35 #include <sys/kernel.h>
36 #include <sys/eventhandler.h>
37 #include <sys/malloc.h>
38 
39 static eventhandler_tag linuxkpi_thread_dtor_tag;
40 
41 static MALLOC_DEFINE(M_LINUX_CURRENT, "linuxcurrent", "LinuxKPI task structure");
42 
43 int
44 linux_alloc_current(struct thread *td, int flags)
45 {
46 	struct proc *proc;
47 	struct thread *td_other;
48 	struct task_struct *ts;
49 	struct task_struct *ts_other;
50 	struct mm_struct *mm;
51 	struct mm_struct *mm_other;
52 
53 	MPASS(td->td_lkpi_task == NULL);
54 
55 	ts = malloc(sizeof(*ts), M_LINUX_CURRENT, flags | M_ZERO);
56 	if (ts == NULL)
57 		return (ENOMEM);
58 
59 	mm = malloc(sizeof(*mm), M_LINUX_CURRENT, flags | M_ZERO);
60 	if (mm == NULL) {
61 		free(ts, M_LINUX_CURRENT);
62 		return (ENOMEM);
63 	}
64 
65 	/* setup new task structure */
66 	atomic_set(&ts->kthread_flags, 0);
67 	ts->task_thread = td;
68 	ts->comm = td->td_name;
69 	ts->pid = td->td_tid;
70 	atomic_set(&ts->usage, 1);
71 	ts->state = TASK_RUNNING;
72 	init_completion(&ts->parked);
73 	init_completion(&ts->exited);
74 
75 	proc = td->td_proc;
76 
77 	/* check if another thread already has a mm_struct */
78 	PROC_LOCK(proc);
79 	FOREACH_THREAD_IN_PROC(proc, td_other) {
80 		ts_other = td_other->td_lkpi_task;
81 		if (ts_other == NULL)
82 			continue;
83 
84 		mm_other = ts_other->mm;
85 		if (mm_other == NULL)
86 			continue;
87 
88 		/* try to share other mm_struct */
89 		if (atomic_inc_not_zero(&mm_other->mm_users)) {
90 			/* set mm_struct pointer */
91 			ts->mm = mm_other;
92 			break;
93 		}
94 	}
95 
96 	/* use allocated mm_struct as a fallback */
97 	if (ts->mm == NULL) {
98 		/* setup new mm_struct */
99 		init_rwsem(&mm->mmap_sem);
100 		atomic_set(&mm->mm_count, 1);
101 		atomic_set(&mm->mm_users, 1);
102 		/* set mm_struct pointer */
103 		ts->mm = mm;
104 		/* clear pointer to not free memory */
105 		mm = NULL;
106 	}
107 
108 	/* store pointer to task struct */
109 	td->td_lkpi_task = ts;
110 	PROC_UNLOCK(proc);
111 
112 	/* free mm_struct pointer, if any */
113 	free(mm, M_LINUX_CURRENT);
114 
115 	return (0);
116 }
117 
118 struct mm_struct *
119 linux_get_task_mm(struct task_struct *task)
120 {
121 	struct mm_struct *mm;
122 
123 	mm = task->mm;
124 	if (mm != NULL) {
125 		atomic_inc(&mm->mm_users);
126 		return (mm);
127 	}
128 	return (NULL);
129 }
130 
131 void
132 linux_mm_dtor(struct mm_struct *mm)
133 {
134 	free(mm, M_LINUX_CURRENT);
135 }
136 
137 void
138 linux_free_current(struct task_struct *ts)
139 {
140 	mmput(ts->mm);
141 	free(ts, M_LINUX_CURRENT);
142 }
143 
144 static void
145 linuxkpi_thread_dtor(void *arg __unused, struct thread *td)
146 {
147 	struct task_struct *ts;
148 
149 	ts = td->td_lkpi_task;
150 	if (ts == NULL)
151 		return;
152 
153 	td->td_lkpi_task = NULL;
154 	put_task_struct(ts);
155 }
156 
157 struct task_struct *
158 linux_pid_task(pid_t pid)
159 {
160 	struct thread *td;
161 	struct proc *p;
162 
163 	/* try to find corresponding thread */
164 	td = tdfind(pid, -1);
165 	if (td != NULL) {
166 		struct task_struct *ts = td->td_lkpi_task;
167 		PROC_UNLOCK(td->td_proc);
168 		return (ts);
169 	}
170 
171 	/* try to find corresponding procedure */
172 	p = pfind(pid);
173 	if (p != NULL) {
174 		FOREACH_THREAD_IN_PROC(p, td) {
175 			struct task_struct *ts = td->td_lkpi_task;
176 			if (ts != NULL) {
177 				PROC_UNLOCK(p);
178 				return (ts);
179 			}
180 		}
181 		PROC_UNLOCK(p);
182 	}
183 	return (NULL);
184 }
185 
186 struct task_struct *
187 linux_get_pid_task(pid_t pid)
188 {
189 	struct thread *td;
190 	struct proc *p;
191 
192 	/* try to find corresponding thread */
193 	td = tdfind(pid, -1);
194 	if (td != NULL) {
195 		struct task_struct *ts = td->td_lkpi_task;
196 		if (ts != NULL)
197 			get_task_struct(ts);
198 		PROC_UNLOCK(td->td_proc);
199 		return (ts);
200 	}
201 
202 	/* try to find corresponding procedure */
203 	p = pfind(pid);
204 	if (p != NULL) {
205 		FOREACH_THREAD_IN_PROC(p, td) {
206 			struct task_struct *ts = td->td_lkpi_task;
207 			if (ts != NULL) {
208 				get_task_struct(ts);
209 				PROC_UNLOCK(p);
210 				return (ts);
211 			}
212 		}
213 		PROC_UNLOCK(p);
214 	}
215 	return (NULL);
216 }
217 
218 static void
219 linux_current_init(void *arg __unused)
220 {
221 	linuxkpi_thread_dtor_tag = EVENTHANDLER_REGISTER(thread_dtor,
222 	    linuxkpi_thread_dtor, NULL, EVENTHANDLER_PRI_ANY);
223 }
224 SYSINIT(linux_current, SI_SUB_EVENTHANDLER, SI_ORDER_SECOND, linux_current_init, NULL);
225 
226 static void
227 linux_current_uninit(void *arg __unused)
228 {
229 	struct proc *p;
230 	struct task_struct *ts;
231 	struct thread *td;
232 
233 	sx_slock(&allproc_lock);
234 	FOREACH_PROC_IN_SYSTEM(p) {
235 		PROC_LOCK(p);
236 		FOREACH_THREAD_IN_PROC(p, td) {
237 			if ((ts = td->td_lkpi_task) != NULL) {
238 				td->td_lkpi_task = NULL;
239 				put_task_struct(ts);
240 			}
241 		}
242 		PROC_UNLOCK(p);
243 	}
244 	sx_sunlock(&allproc_lock);
245 
246 	EVENTHANDLER_DEREGISTER(thread_dtor, linuxkpi_thread_dtor_tag);
247 }
248 SYSUNINIT(linux_current, SI_SUB_EVENTHANDLER, SI_ORDER_SECOND, linux_current_uninit, NULL);
249