CS433 Linux Kernel Programming

Homework 6 on Creating and Destroying Kernel Threads

• Print some information of all the processes pointed by init_task, something similiar to "ps -ef", including UID, PID, PPID, thread name, etc.
• Create five kernel threads using the following methods:
  • Create 2 threads using kernel_thread()
  • Create 2 threads on a dual-core machine (4 on a quad-core machine) using smpboot_register_percpu_thread() which creates kthread place holder through kthread_creat_list which kthreadd periodically checks to create a kernel thread eventually using kernel_thread().
• Print some information of all the processes including the five threads. The output will be part of dmesg or messages. Again, try to follow the "ps -ef" format when printing all the processes including your own threads.

UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 09:36 ?        00:00:00 /sbin/init
root         2     0  0 09:36 ?        00:00:00 [kthreadd]
root         3     2  0 09:36 ?        00:00:00 [ksoftirqd/0]
root         4     2  0 09:36 ?        00:00:00 [kworker/0]
root         5     2  0 09:36 ?        00:00:00 [migration/0]
...

root         10     2  0 09:36 ?        00:00:00 [my_hotplugd/0]
root         12     2  0 09:36 ?        00:00:00 [my_hotplugd/1]

...
root       579     2  0 09:36 ?        00:00:00 [hid_compat]

root       613     1  0 09:36 ?        00:00:00 [My_name: my_ker_thd_1]
root       614     2  0 09:36 ?        00:00:00 [My_name: my_ker_thd_2]

...
  

For creating the first 2 threads try the following procedure:

• Declare the functions that will create threads and those threads that will actually do something:

  static void my_kernel_thread_create_1(void);
  static void my_kernel_thread_create_2(void);
  
  ...
  
  static void my_kernel_thread_create_1(void){
    int mypid;
    printk(KERN_NOTICE "My_name: Calling kernel_thread(my_ker_thd_1)\n");
    mypid = kernel_thread(m_k_t_do_something_1, NULL, CLONE_KERNEL);
    printk(KERN_NOTICE "My_name: my_ker_thd_1 = %d\n", mypid);
  }
  
  static void my_kernel_thread_create_2(void){
    int mypid;
    printk(KERN_NOTICE "My_name: Calling kernel_thread(my_ker_thd_2)\n");
    mypid = kernel_thread(m_k_t_do_something_2, NULL, CLONE_KERNEL);
    printk(KERN_NOTICE "My_name: my_ker_thd_2 = %d\n", mypid);
  }
  
  ...
  
  static void m_k_t_do_something_1(void){
    struct task_struct *curtask = current;
    strcpy(curtask->comm, "My name: m_k_t_do_something_1");
    set_task_state(curtask, TASK_RUNNING);
    printk(KERN_NOTICE "My name: m_k_t_do_something_1 is about to be scheduled.\n");
    schedule();
    printk(KERN_NOTICE "My_name: m_k_t_do_something_1 is now scheduled.\n");
  }
  
  static void m_k_t_do_something_2(void){
    struct task_struct *curtask = current;
    strcpy(curtask->comm, "My_name: m_k_t_do_something_2");
    set_task_state(curtask, TASK_RUNNING);
    printk(KERN_NOTICE "My_name: m_k_t_do_something_2 is about to be scheduled.\n");
    schedule();
    printk(KERN_NOTICE "My_name: m_k_t_do_something_2 is now scheduled.\n");
  }
  ...
  

• Call those functions that will create these threads.

  ...
  print some info on all the processes on runqueue;
  ...
  printk(KERN_NOTICE "My_name: m_k_t_do_something threads are about to be created.\n");
  my_kernel_thread_create_1();
  my_kernel_thread_create_2();
  ...
  printk(KERN_NOTICE "My_name: m_k_t_do_something threads are created.\n");
  ...
  print some info on all the processes on runqueue;
  ...
  run_init_process("/sbin/init");
  ...
  

• Remember to print process info before you call these functions, after you calll the functions, and after terminate

For creating the second type of threads, follow the procedure for creating ksoftirqd and kworker discussed in class:

• Declare early_initcall(spawn_my_hotplug_threads);

  static __init int spawn_my_hotplug_threads(void){
           BUG_ON(smpboot_register_percpu_thread(&softirq_threads));
           return 0;
  }
  

• Declare and define smp_hotplug_thread my_hotplug_threads:

  
  static struct smp_hotplug_thread my_hotplug_threads = {
          .store                  = &my_hotplugd,
          .thread_fn              = run_my_hotplugd,
          .thread_comm            = "my_hotplugd/%u",
  };
  
  static void run_my_hotplugd(unsigned int cpu) {
  	...
          print something to indicate that my_hotplugd/{0,1,2,3} are up and running
  	...
  }
  

• Refer to softirq_threads in softirq.c file as an example. Also check init_workqueues in workqueue.c which creates kworkers.

For printing some info on processes, try the following:

...
struct task_struct *tmp_tsk;
...
tmp_tsk = current;
for_each_process(tmp_tsk)        {
    ...
    print some info on all the processes on runqueue;
    ...
}

Now, remove all the threads you created and print all the processes, something similiar to "ps -ef".

Submit a patch file, only the portion of the code you actually modified, not all the files. Include screen shots/dmesg that show that it worked.