--- name: "kproc_start" section: "9" platform: "linux" package: "freebsd-manpages" version: "6.0-5" release: "Debian 4.0 (Etch)" platforms: ["linux", "freebsd"] url: "https://new.carta.tech/kproc_start" --- # kproc\_start(9) kernel threads ## NAME **kproc\_start**, **kproc\_shutdown**, **kthread\_create**, **kthread\_exit**, **kthread\_resume**, **kthread\_suspend**, **kthread\_suspend\_check** – kernel threads ## SYNOPSIS **#include \** *void*\ **kproc\_start**(*const void \*udata*); *void*\ **kproc\_shutdown**(*void \*arg*, *int howto*); *int*\ **kthread\_create**(*void (\*func)(void \*)*, *void \*arg*, *struct proc \*\*newpp*, *int flags*, *int pages*, *const char \*fmt*, *...*); *void*\ **kthread\_exit**(*int ecode*); *int*\ **kthread\_resume**(*struct proc \*p*); *int*\ **kthread\_suspend**(*struct proc \*p*, *int timo*); *void*\ **kthread\_suspend\_check**(*struct proc \*p*); ## DESCRIPTION The function **kproc\_start**() is used to start “internal” daemons such as bufdaemon, pagedaemon, vmdaemon, and the syncer and is intended to be called from [SYSINIT(9)](/SYSINIT/9.md). The *udata* argument is actually a pointer to a struct kproc\_desc which describes the kernel thread that should be created: ``` struct kproc_desc { char *arg0; void (*func)(void); struct proc **global_procpp; }; ``` The structure members are used by **kproc\_start**() as follows: - *arg0* String to be used for the name of the process. This string will be copied into the *p\_comm* member of the new process' struct proc. - *func* The main function for this kernel process to run. - *global\_procpp* A pointer to a struct proc pointer that should be updated to point to the newly created process' process structure. If this variable is NULL, then it is ignored. The **kthread\_create**() function is used to create a kernel thread. The new thread shares its address space with process 0, the swapper process, and runs in kernel mode only. The *func* argument specifies the function that the thread should execute. The *arg* argument is an arbitrary pointer that is passed in as the only argument to *func* when it is called by the new process. The *newpp* pointer points to a struct proc pointer that is to be updated to point to the newly created process. If this argument is NULL, then it is ignored. The *flags* argument specifies a set of flags as described in [rfork(2)](/rfork/2.md). The *pages* argument specifies the size of the new kernel thread's stack in pages. If 0 is used, the default kernel stack size is allocated. The rest of the arguments form a [printf(9)](/printf/9.md) argument list that is used to build the name of the new thread and is stored in the *p\_comm* member of the new thread's struct proc. The **kthread\_exit**() function is used to terminate kernel threads. It should be called by the main function of the kernel thread rather than letting the main function return to its caller. The *ecode* argument specifies the exit status of the thread. While exiting, the function exit1(9) will initiate a call to [wakeup(9)](/wakeup/9.md) on the thread handle. The **kthread\_resume**(), **kthread\_suspend**(), and **kthread\_suspend\_check**() functions are used to suspend and resume a kernel thread. During the main loop of its execution, a kernel thread that wishes to allow itself to be suspended should call **kthread\_suspend\_check**() passing in *curproc* as the only argument. This function checks to see if the kernel thread has been asked to suspend. If it has, it will [tsleep(9)](/tsleep/9.md) until it is told to resume. Once it has been told to resume it will return allowing execution of the kernel thread to continue. The other two functions are used to notify a kernel thread of a suspend or resume request. The *p* argument points to the struct proc of the kernel thread to suspend or resume. For **kthread\_suspend**(), the *timo* argument specifies a timeout to wait for the kernel thread to acknowledge the suspend request and suspend itself. The **kproc\_shutdown**() function is meant to be registered as a shutdown event for kernel threads that need to be suspended voluntarily during system shutdown so as not to interfere with system shutdown activities. The actual suspension of the kernel thread is done with **kthread\_suspend**(). ## RETURN VALUES The **kthread\_create**(), **kthread\_resume**(), and **kthread\_suspend**() functions return zero on success and non-zero on failure. ## EXAMPLES This example demonstrates the use of a struct kproc\_desc and the functions **kproc\_start**(), **kproc\_shutdown**(), and **kthread\_suspend\_check**() to run the “bufdaemon” process. ``` static struct proc *bufdaemonproc; static struct kproc_desc buf_kp = { "bufdaemon", buf_daemon, &bufdaemonproc }; SYSINIT(bufdaemon, SI_SUB_KTHREAD_BUF, SI_ORDER_FIRST, kproc_start, &buf_kp) static void buf_daemon() { ... /* * This process needs to be suspended prior to shutdown sync. */ EVENTHANDLER_REGISTER(shutdown_pre_sync, kproc_shutdown, bufdaemonproc, SHUTDOWN_PRI_LAST); ... for (;;) { kthread_suspend_check(bufdaemonproc); ... } } ``` ## ERRORS The **kthread\_resume**() and **kthread\_suspend**() functions will fail if: - \[EINVAL\] The *p* argument does not reference a kernel thread. The **kthread\_create**() function will fail if: - \[EAGAIN\] The system-imposed limit on the total number of processes under execution would be exceeded. The limit is given by the [sysctl(3)](/sysctl/3.md) MIB variable KERN\_MAXPROC. - \[EINVAL\] The RFCFDG flag was specified in the *flags* parameter. ## SEE ALSO [rfork(2)](/rfork/2.md), exit1(9), [SYSINIT(9)](/SYSINIT/9.md), [wakeup(9)](/wakeup/9.md) ## HISTORY The **kproc\_start**() function first appeared in FreeBSD 2.2. The **kproc\_shutdown**(), **kthread\_create**(), **kthread\_exit**(), **kthread\_resume**(), **kthread\_suspend**(), and **kthread\_suspend\_check**() functions were introduced in FreeBSD 4.0. Prior to FreeBSD 5.0, the **kproc\_shutdown**(), **kthread\_resume**(), **kthread\_suspend**(), and **kthread\_suspend\_check**() functions were named **shutdown\_kproc**(), **resume\_kproc**(), **shutdown\_kproc**(), and **kproc\_suspend\_loop**(), respectively.