41 #include <linux/filter.h>
64 	/* The struct pid of the task whose filter triggered the notification */
67 	/* The "cookie" for this request; this is unique for this filter. */
145  *            filter->notify_lock.
160  * struct action_cache - per-filter cache of seccomp actions per
164  *		  filter will always allow the syscall, for the
167  *		  filter will always allow the syscall, for the
194  *	  A filter's reference count is incremented for each directly
195  *	  attached task, once for the dependent filter, and if
197  *	  the filter can be freed.
198  * @users: A filter's @users count is incremented for each directly
199  *         attached task (filter installation, fork(), thread_sync),
200  *	   and once for the dependent filter (tracked in filter->prev).
202  *	   users of that filter exist. No new tasks can get associated with
203  *	   this filter after reaching 0. The @users count is always smaller
205  *	   the filter can be freed.
210  * @prev: points to a previously installed, or inherited, filter
218  * with current->seccomp.filter, the most recently attached or inherited filter.
269  *	seccomp_check_filter - verify seccomp filter code
270  *	@filter: filter to verify
271  *	@flen: length of filter
273  * Takes a previously checked filter (by bpf_check_classic) and
274  * redirects all filter code that loads struct sk_buff data
280 static int seccomp_check_filter(struct sock_filter *filter, unsigned int flen)  in seccomp_check_filter()  argument
284 		struct sock_filter *ftest = &filter[pc];  in seccomp_check_filter()
364  * @sfilter: The seccomp filter
401  *         unless filter returned SECCOMP_RET_ALLOW, in which case it will
410 	/* Make sure cross-thread synced filter points somewhere sane. */  in seccomp_run_filters()
412 			READ_ONCE(current->seccomp.filter);  in seccomp_run_filters()
458 	 * filter) is set.  in seccomp_assign_mode()
488  * seccomp filter.
511 		     is_ancestor(thread->seccomp.filter,  in seccomp_can_sync_threads()
512 				 caller->seccomp.filter)))  in seccomp_can_sync_threads()
526 static inline void seccomp_filter_free(struct seccomp_filter *filter)  in seccomp_filter_free()  argument
528 	if (filter) {  in seccomp_filter_free()
529 		bpf_prog_destroy(filter->prog);  in seccomp_filter_free()
530 		kfree(filter);  in seccomp_filter_free()
555 	/* Notify about any unused filters in the task's former filter tree. */  in __seccomp_filter_release()
562  * seccomp_filter_release - Detach the task from its filter tree,
566  * @tsk: task the filter should be released from.
569  * it detaches it from its filter tree. PF_EXITING has to be set
580 	orig = tsk->seccomp.filter;  in seccomp_filter_release()
581 	/* Detach task from its filter tree. */  in seccomp_filter_release()
582 	tsk->seccomp.filter = NULL;  in seccomp_filter_release()
588  * seccomp_sync_threads: sets all threads to use current's filter
626 		__seccomp_filter_release(thread->seccomp.filter);  in seccomp_sync_threads()
628 		/* Make our new filter tree visible. */  in seccomp_sync_threads()
629 		smp_store_release(&thread->seccomp.filter,  in seccomp_sync_threads()
630 				  caller->seccomp.filter);  in seccomp_sync_threads()
656  * seccomp_prepare_filter: Prepares a seccomp filter for use.
659  * Returns filter on success or an ERR_PTR on failure.
678 	 * Installing a seccomp filter requires that the task has  in seccomp_prepare_filter()
717 	struct seccomp_filter *filter = ERR_PTR(-EFAULT);  in seccomp_prepare_user_filter()  local
725 		fprog.filter = compat_ptr(fprog32.filter);  in seccomp_prepare_user_filter()
730 	filter = seccomp_prepare_filter(&fprog);  in seccomp_prepare_user_filter()
732 	return filter;  in seccomp_prepare_user_filter()
737  * seccomp_is_const_allow - check if filter is constant allow with given data
753 		struct sock_filter *insn = &fprog->filter[pc];  in seccomp_is_const_allow()
810 	/* ran off the end of the filter?! */  in seccomp_is_const_allow()
824 		/* The new filter must be as restrictive as the last. */  in seccomp_cache_prepare_bitmap()
845 		 * atomic clear_bit() not needed, filter not visible yet.  in seccomp_cache_prepare_bitmap()
852  * seccomp_cache_prepare - emulate the filter to find cacheable syscalls
853  * @sfilter: The seccomp filter
878  * seccomp_attach_filter: validate and attach filter
879  * @flags:  flags to change filter behavior
880  * @filter: seccomp filter to add to the current process
886  *     seccomp mode or did not have an ancestral seccomp filter
890 				  struct seccomp_filter *filter)  in seccomp_attach_filter()  argument
897 	/* Validate resulting filter length. */  in seccomp_attach_filter()
898 	total_insns = filter->prog->len;  in seccomp_attach_filter()
899 	for (walker = current->seccomp.filter; walker; walker = walker->prev)  in seccomp_attach_filter()
919 		filter->log = true;  in seccomp_attach_filter()
923 		filter->wait_killable_recv = true;  in seccomp_attach_filter()
926 	 * If there is an existing filter, make it the prev and don't drop its  in seccomp_attach_filter()
929 	filter->prev = current->seccomp.filter;  in seccomp_attach_filter()
930 	seccomp_cache_prepare(filter);  in seccomp_attach_filter()
931 	current->seccomp.filter = filter;  in seccomp_attach_filter()
934 	/* Now that the new filter is in place, synchronize to all threads. */  in seccomp_attach_filter()
941 static void __get_seccomp_filter(struct seccomp_filter *filter)  in __get_seccomp_filter()  argument
943 	refcount_inc(&filter->refs);  in __get_seccomp_filter()
946 /* get_seccomp_filter - increments the reference count of the filter on @tsk */
949 	struct seccomp_filter *orig = tsk->seccomp.filter;  in get_seccomp_filter()
1068 static u64 seccomp_next_notify_id(struct seccomp_filter *filter)  in seccomp_next_notify_id()  argument
1072 	 * filter.  in seccomp_next_notify_id()
1074 	lockdep_assert_held(&filter->notify_lock);  in seccomp_next_notify_id()
1075 	return filter->notif->next_id++;  in seccomp_next_notify_id()
1251 		/* Let the filter pass back 16 bits of data. */  in __seccomp_filter()
1310 		 * Note that the "match" filter will always be NULL for  in __seccomp_filter()
1414 static void seccomp_notify_free(struct seccomp_filter *filter)  in seccomp_notify_free()  argument
1416 	kfree(filter->notif);  in seccomp_notify_free()
1417 	filter->notif = NULL;  in seccomp_notify_free()
1420 static void seccomp_notify_detach(struct seccomp_filter *filter)  in seccomp_notify_detach()  argument
1424 	if (!filter)  in seccomp_notify_detach()
1427 	mutex_lock(&filter->notify_lock);  in seccomp_notify_detach()
1433 	list_for_each_entry(knotif, &filter->notif->notifications, list) {  in seccomp_notify_detach()
1449 	seccomp_notify_free(filter);  in seccomp_notify_detach()
1450 	mutex_unlock(&filter->notify_lock);  in seccomp_notify_detach()
1455 	struct seccomp_filter *filter = file->private_data;  in seccomp_notify_release()  local
1457 	seccomp_notify_detach(filter);  in seccomp_notify_release()
1458 	__put_seccomp_filter(filter);  in seccomp_notify_release()
1464 find_notification(struct seccomp_filter *filter, u64 id)  in find_notification()  argument
1468 	lockdep_assert_held(&filter->notify_lock);  in find_notification()
1470 	list_for_each_entry(cur, &filter->notif->notifications, list) {  in find_notification()
1487 static int recv_wait_event(struct seccomp_filter *filter)  in recv_wait_event()  argument
1492 	if (refcount_read(&filter->users) == 0)  in recv_wait_event()
1495 	if (atomic_dec_if_positive(&filter->notif->requests) >= 0)  in recv_wait_event()
1499 		ret = prepare_to_wait_event(&filter->wqh, &wait, TASK_INTERRUPTIBLE);  in recv_wait_event()
1501 		if (atomic_dec_if_positive(&filter->notif->requests) >= 0)  in recv_wait_event()
1503 		if (refcount_read(&filter->users) == 0)  in recv_wait_event()
1511 	finish_wait(&filter->wqh, &wait);  in recv_wait_event()
1515 static long seccomp_notify_recv(struct seccomp_filter *filter,  in seccomp_notify_recv()  argument
1531 	ret = recv_wait_event(filter);  in seccomp_notify_recv()
1535 	mutex_lock(&filter->notify_lock);  in seccomp_notify_recv()
1536 	list_for_each_entry(cur, &filter->notif->notifications, list) {  in seccomp_notify_recv()
1558 	wake_up_poll(&filter->wqh, EPOLLOUT | EPOLLWRNORM);  in seccomp_notify_recv()
1561 	mutex_unlock(&filter->notify_lock);  in seccomp_notify_recv()
1572 		mutex_lock(&filter->notify_lock);  in seccomp_notify_recv()
1573 		knotif = find_notification(filter, unotif.id);  in seccomp_notify_recv()
1576 			if (should_sleep_killable(filter, knotif))  in seccomp_notify_recv()
1579 			atomic_inc(&filter->notif->requests);  in seccomp_notify_recv()
1580 			wake_up_poll(&filter->wqh, EPOLLIN | EPOLLRDNORM);  in seccomp_notify_recv()
1582 		mutex_unlock(&filter->notify_lock);  in seccomp_notify_recv()
1588 static long seccomp_notify_send(struct seccomp_filter *filter,  in seccomp_notify_send()  argument
1605 	ret = mutex_lock_interruptible(&filter->notify_lock);  in seccomp_notify_send()
1609 	knotif = find_notification(filter, resp.id);  in seccomp_notify_send()
1626 	if (filter->notif->flags & SECCOMP_USER_NOTIF_FD_SYNC_WAKE_UP)  in seccomp_notify_send()
1631 	mutex_unlock(&filter->notify_lock);  in seccomp_notify_send()
1635 static long seccomp_notify_id_valid(struct seccomp_filter *filter,  in seccomp_notify_id_valid()  argument
1645 	ret = mutex_lock_interruptible(&filter->notify_lock);  in seccomp_notify_id_valid()
1649 	knotif = find_notification(filter, id);  in seccomp_notify_id_valid()
1655 	mutex_unlock(&filter->notify_lock);  in seccomp_notify_id_valid()
1659 static long seccomp_notify_set_flags(struct seccomp_filter *filter,  in seccomp_notify_set_flags()  argument
1667 	ret = mutex_lock_interruptible(&filter->notify_lock);  in seccomp_notify_set_flags()
1670 	filter->notif->flags = flags;  in seccomp_notify_set_flags()
1671 	mutex_unlock(&filter->notify_lock);  in seccomp_notify_set_flags()
1675 static long seccomp_notify_addfd(struct seccomp_filter *filter,  in seccomp_notify_addfd()  argument
1713 	ret = mutex_lock_interruptible(&filter->notify_lock);  in seccomp_notify_addfd()
1717 	knotif = find_notification(filter, addfd.id);  in seccomp_notify_addfd()
1752 	mutex_unlock(&filter->notify_lock);  in seccomp_notify_addfd()
1768 	mutex_lock(&filter->notify_lock);  in seccomp_notify_addfd()
1782 	mutex_unlock(&filter->notify_lock);  in seccomp_notify_addfd()
1792 	struct seccomp_filter *filter = file->private_data;  in seccomp_notify_ioctl()  local
1798 		return seccomp_notify_recv(filter, buf);  in seccomp_notify_ioctl()
1800 		return seccomp_notify_send(filter, buf);  in seccomp_notify_ioctl()
1803 		return seccomp_notify_id_valid(filter, buf);  in seccomp_notify_ioctl()
1805 		return seccomp_notify_set_flags(filter, arg);  in seccomp_notify_ioctl()
1812 		return seccomp_notify_addfd(filter, buf, _IOC_SIZE(cmd));  in seccomp_notify_ioctl()
1821 	struct seccomp_filter *filter = file->private_data;  in seccomp_notify_poll()  local
1825 	poll_wait(file, &filter->wqh, poll_tab);  in seccomp_notify_poll()
1827 	if (mutex_lock_interruptible(&filter->notify_lock) < 0)  in seccomp_notify_poll()
1830 	list_for_each_entry(cur, &filter->notif->notifications, list) {  in seccomp_notify_poll()
1839 	mutex_unlock(&filter->notify_lock);  in seccomp_notify_poll()
1841 	if (refcount_read(&filter->users) == 0)  in seccomp_notify_poll()
1854 static struct file *init_listener(struct seccomp_filter *filter)  in init_listener()  argument
1859 	filter->notif = kzalloc(sizeof(*(filter->notif)), GFP_KERNEL);  in init_listener()
1860 	if (!filter->notif)  in init_listener()
1863 	filter->notif->next_id = get_random_u64();  in init_listener()
1864 	INIT_LIST_HEAD(&filter->notif->notifications);  in init_listener()
1867 				 filter, O_RDWR);  in init_listener()
1872 	__get_seccomp_filter(filter);  in init_listener()
1876 		seccomp_notify_free(filter);  in init_listener()
1883  * If so, we'll want to reject this filter.
1887  * we use current->seccomp.filter.
1898 	for (cur = current->seccomp.filter; cur; cur = cur->prev) {  in has_duplicate_listener()
1907  * seccomp_set_mode_filter: internal function for setting seccomp filter
1908  * @flags:  flags to change filter behavior
1909  * @filter: struct sock_fprog containing filter
1912  * Every filter successfully installed will be evaluated (in reverse order)
1920 				    const char __user *filter)  in seccomp_set_mode_filter()  argument
1952 	/* Prepare the new filter before holding any locks. */  in seccomp_set_mode_filter()
1953 	prepared = seccomp_prepare_user_filter(filter);  in seccomp_set_mode_filter()
1993 	/* Do not free the successfully attached filter. */  in seccomp_set_mode_filter()
2019 					   const char __user *filter)  in seccomp_set_mode_filter()  argument
2098  * @filter: optional struct sock_fprog for use with SECCOMP_MODE_FILTER
2102 long prctl_set_seccomp(unsigned long seccomp_mode, void __user *filter)  in prctl_set_seccomp()  argument
2111 		 * Setting strict mode through prctl always ignored filter,  in prctl_set_seccomp()
2119 		uargs = filter;  in prctl_set_seccomp()
2133 	struct seccomp_filter *orig, *filter;  in get_nth_filter()  local
2147 	orig = task->seccomp.filter;  in get_nth_filter()
2152 	for (filter = orig; filter; filter = filter->prev)  in get_nth_filter()
2156 		filter = ERR_PTR(-ENOENT);  in get_nth_filter()
2161 	for (filter = orig; filter && count > 1; filter = filter->prev)  in get_nth_filter()
2164 	if (WARN_ON(count != 1 || !filter)) {  in get_nth_filter()
2165 		filter = ERR_PTR(-ENOENT);  in get_nth_filter()
2169 	__get_seccomp_filter(filter);  in get_nth_filter()
2173 	return filter;  in get_nth_filter()
2179 	struct seccomp_filter *filter;  in seccomp_get_filter()  local
2188 	filter = get_nth_filter(task, filter_off);  in seccomp_get_filter()
2189 	if (IS_ERR(filter))  in seccomp_get_filter()
2190 		return PTR_ERR(filter);  in seccomp_get_filter()
2192 	fprog = filter->prog->orig_prog;  in seccomp_get_filter()
2194 		/* This must be a new non-cBPF filter, since we save  in seccomp_get_filter()
2195 		 * every cBPF filter's orig_prog above when  in seccomp_get_filter()
2206 	if (copy_to_user(data, fprog->filter, bpf_classic_proglen(fprog)))  in seccomp_get_filter()
2210 	__put_seccomp_filter(filter);  in seccomp_get_filter()
2218 	struct seccomp_filter *filter;  in seccomp_get_metadata()  local
2234 	filter = get_nth_filter(task, kmd.filter_off);  in seccomp_get_metadata()
2235 	if (IS_ERR(filter))  in seccomp_get_metadata()
2236 		return PTR_ERR(filter);  in seccomp_get_metadata()
2238 	if (filter->log)  in seccomp_get_metadata()
2245 	__put_seccomp_filter(filter);  in seccomp_get_metadata()
2487 		char *status = cached ? "ALLOW" : "FILTER";  in device_initcall()
2509 	f = READ_ONCE(task->seccomp.filter);  in proc_pid_seccomp_cache()
2515 	/* prevent filter from being freed while we are printing it */  in proc_pid_seccomp_cache()