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 atomic_set(&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 bool 219 linux_task_exiting(struct task_struct *task) 220 { 221 struct proc *p; 222 bool ret; 223 224 ret = false; 225 p = pfind(task->pid); 226 if (p != NULL) { 227 if ((p->p_flag & P_WEXIT) != 0) 228 ret = true; 229 PROC_UNLOCK(p); 230 } 231 return (ret); 232 } 233 234 static void 235 linux_current_init(void *arg __unused) 236 { 237 lkpi_alloc_current = linux_alloc_current; 238 linuxkpi_thread_dtor_tag = EVENTHANDLER_REGISTER(thread_dtor, 239 linuxkpi_thread_dtor, NULL, EVENTHANDLER_PRI_ANY); 240 } 241 SYSINIT(linux_current, SI_SUB_EVENTHANDLER, SI_ORDER_SECOND, linux_current_init, NULL); 242 243 static void 244 linux_current_uninit(void *arg __unused) 245 { 246 struct proc *p; 247 struct task_struct *ts; 248 struct thread *td; 249 250 sx_slock(&allproc_lock); 251 FOREACH_PROC_IN_SYSTEM(p) { 252 PROC_LOCK(p); 253 FOREACH_THREAD_IN_PROC(p, td) { 254 if ((ts = td->td_lkpi_task) != NULL) { 255 td->td_lkpi_task = NULL; 256 put_task_struct(ts); 257 } 258 } 259 PROC_UNLOCK(p); 260 } 261 sx_sunlock(&allproc_lock); 262 EVENTHANDLER_DEREGISTER(thread_dtor, linuxkpi_thread_dtor_tag); 263 lkpi_alloc_current = linux_alloc_current_noop; 264 } 265 SYSUNINIT(linux_current, SI_SUB_EVENTHANDLER, SI_ORDER_SECOND, linux_current_uninit, NULL); 266