Связанные списки ядра Linux - и сортировка

Question

Я реализую некоторые системные вызовы, которые в основном должны поддерживать список процессов и список открытых файлов с каждым процессом.Однако мне трудно отлаживать код, который требует перекомпиляции снова и снова.

Вот, вероятно, мои основные проблемы:

1. Когда и как я могуинициализировать список, сохраняя процессы?В настоящее время я проверяю, пуст ли список перед инициализацией, но он не работает.Я также попытался head == head->prev->next, но не смог.

2. Как правильно вызвать list_sort с учетом связанной функции сравнения?Я получаю сообщение об ошибке

[1827.710802] BUG: невозможно обработать запрос подкачки ядра по адресу fffff550

[1827.710808] IP: [] сравнить + 0x8/ 0x20

[1827.710814] * pde = 00a32067 * pte = 00000000

Это код.Я был бы очень признателен, если бы вы просмотрели его, особенно системный вызов init, правильное поведение которого зависят от других.

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/pid.h>
#include <linux/list.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/fdtable.h>
#include <linux/list_sort.h>
#include <linux/slab.h>


struct fileDescriptor {
    int fd;
    struct list_head list;
};

struct processInfo {
    struct task_struct task;
    int len_files;
    struct fileDescriptor listHead;
    struct list_head list;
};

struct processInfo listHead;

int compare(void* priv, struct list_head *a, struct list_head *b)
{
    struct processInfo *p1 = container_of(a, struct processInfo, list);
    struct processInfo *p2 = container_of(b, struct processInfo, list);

    if (p1->task.pid > p2->task.pid) return -1;
    else return 1;
}


asmlinkage long sys_init_process_list(pid_t p)
{   
    struct pid* pid;
    struct task_struct *task;
    struct files_struct *processFiles;
    struct fdtable *filesTable;
    struct processInfo *newProcess;

    if(list_empty(&listHead.list))
    {
        printk("____list_empty_____\n");
        INIT_LIST_HEAD(&listHead.list);
    }
    else
        printk("____list_not_empty_____\n");


    pid = find_get_pid(p);
    if (pid == NULL)
    {
        sys_init_process_list(1);
        return 1;
    }
    else 
    {
        struct list_head *list;
        struct task_struct *childTask;
        struct fileDescriptor *newfd;
        int i = 0;
        task = pid_task(pid, PIDTYPE_PID);
        newProcess = (struct processInfo*) kmalloc(sizeof(*newProcess), GFP_KERNEL);
        //copy task structure
        newProcess->task = *task;
        //adding file descriptors
        INIT_LIST_HEAD(&(newProcess->listHead).list);
        processFiles = task->files;
        filesTable = files_fdtable(processFiles);
        while (filesTable->fd[i] != NULL)
        {
            newfd = (struct fileDescriptor*) kmalloc(sizeof(*newfd), GFP_KERNEL);
            newfd->fd = i;
            INIT_LIST_HEAD(&newfd->list);
            list_add_tail(&(newfd->list), &(newProcess->listHead).list);
            i++;
        }
        newProcess->len_files = i;
        INIT_LIST_HEAD(&newProcess->list);
        // add the new node to mylist
        list_add_tail(&(newProcess->list), &(listHead.list));        
        //adding childern
        list_for_each(list, &task->children)
        {
            childTask = list_entry(list, struct task_struct, sibling);
            sys_init_process_list(childTask->pid);
        }
        return 0;
    }
}
//////////////////////////////////////////
asmlinkage long sys_sort_process_list(void)
{
    if(list_empty(&listHead.list))
    {
        printk("empty list\n");
        return 1;
    }
    list_sort(NULL, &listHead.list, compare);
    return 0;
}
////////////////////////////////////////
asmlinkage long sys_print_process_list(void)
{

    struct processInfo *aProcess;

    if (sys_sort_process_list())
    {
        printk("empty list\n");
        return 1;
    }

    list_for_each_entry(aProcess, &listHead.list, list)
    {
        printk("%d, %d\n", (aProcess->task).pid, aProcess->len_files);
    }
    return 0;
}
//////////////////////////////////////////////////
asmlinkage long sys_clear_process_list(void)
{   
    struct processInfo *aProcess, *tmp;

    if(list_empty(&listHead.list))
    {
        printk("empty list\n");
        return 1;
    }

    printk("deleting the list");

    list_for_each_entry_safe(aProcess, tmp, &listHead.list, list)
    {
        printk("freeing %d", (aProcess->task).pid);
        list_del(&aProcess->list);
        kfree(aProcess);
    }

    return 0;
}

РЕДАКТИРОВАТЬ: мне удалось как-то решить мою проблему с помощью «статического определения», которое сделаново время компиляции, а именно, я превратил

struct processInfo listHead;

в

struct processInfo listHead =
{
    .list = LIST_HEAD_INIT(listHead.list)
}

, и теперь все, кажется, работает просто отлично.Хотя я не уверен, что это лучший способ, поэтому я оставлю вопрос открытым, чтобы можно было добавить другие возможные решения.

Answer 1

В отличие от многих других объектов, инициализация нуля связанного списка оставляет его в недопустимом состоянии .То есть ни одна из функций связанного списка не может быть использована для инициализированного нулями списка.Четный list_empty один.

Правильная инициализация связанного списка включает LIST_HEAD_INIT (в качестве инициализатора структуры) или INIT_LIST_HEAD (во время выполнения).