int hanoi(int n, char from, char to, char via) {
    Frame stk[64];
    Frame *top = stk - 1;

    // Function call: push a new frame (PC=0) onto the stack
    #define call(...) ({ *(++top) = (Frame){.pc = 0, __VA_ARGS__}; })
    
    // Function return: pop the top-most frame
    #define ret(val) ({ top--; retval = (val); })


    // The last function-return's value. It is not obvious
    // that we only need one retval.
    int retval = 0;

    // The initial call to the recursive function
    call(n, from, to, via);

    while (1) {
        // Fetch the top-most frame.
        Frame *f = top;
        printf("pc=%d\n",  f->pc);
       
       
        if (top < stk) {
           // No top-most frame any more; we're done.
            break;
        }

        // Jumps may change this default next pc.
        int next_pc = f->pc + 1;
        
        // Single step execution.

        // Extract the parameters from the current frame. (It's
        // generally a bad idea to reuse variable names in
        // practice; but we did it here for readability.)
        int n = f->n, from = f->from, to = f->to, via = f->via;
        
        switch (f->pc) {
            case 0:
                if (n == 1) {
                    printf("%c -> %c\n", from, to);
                    ret(1);
                }
                break;
            case 1: call(n - 1, from, via, to); break;
            case 2: f->c1 = retval; break;
            case 3: call(1, from, to, via); break;
            case 4: call(n - 1, via, to, from); break;
            case 5: f->c2 = retval; break;
            case 6: ret(f->c1 + f->c2 + 1); break;
            default: assert(0);
        }

        f->pc = next_pc;
    }

    return retval;
}

1  typedef struct __lock_t {
2      int flag;
3      int guard;
4      queue_t *q;
5  } lock_t;

6  void lock_init(lock_t *m) {
7      m->flag = 0;
8      m->guard = 0;
9      queue_init(m->q);
10 }

11 void lock(lock_t *m) {
12     while (TestAndSet(&m->guard, 1) == 1) // acquire guard lock by spinning
13         ; // 自旋直到获取到guard锁
14     if (m->flag == 0) { // 如果flag为0，表示锁未被占用
15         m->flag = 1; // 获取锁
16         m->guard = 0; // 释放guard锁
17     } else { // 锁已被占用
18         queue_add(m->q, gettid()); // 将当前线程加入等待队列
19         m->guard = 0; // 释放guard锁
20         park(); // 将线程挂起，进入睡眠状态
21     }
22 }

23 void unlock(lock_t *m) {
24     while (TestAndSet(&m->guard, 1) == 1) // acquire guard lock by spinning
25         ; // 自旋直到获取到guard锁
26     if (queue_empty(m->q)) { // 如果队列为空，表示没有等待线程
27         m->flag = 0; // 释放锁
28     } else {
29         unpark(queue_remove(m->q)); // 唤醒等待队列中的下一个线程
30     }
31     m->guard = 0; // 释放guard锁
32 }

void lock(lock_t *m) {
    while (TestAndSet(&m->guard, 1) == 1)
        ;  // 自旋等待获取guard锁
    
    if (m->flag == 0) {  // 如果锁未被占用
        m->flag = 1;     // 获取锁
        m->guard = 0;    // 释放guard锁
    } else {             // 如果锁被占用
        queue_add(m->q, gettid());  // 将当前线程加入等待队列
        setpark();                  // 设置park状态，防止丢失唤醒
        m->guard = 0;               // 释放guard锁
        park();                     // 挂起线程，等待被唤醒
        // 唤醒后继续执行
    }
}

char name[100] = "\0"; 
            pid_t p = 0; 
            pid_t pp = 0; 
            getPPid(stat_detail, &p, name, &pp);

            ProcessNode* node = creatnode(name, p, pp);
            ProcessNode* proc = process_table[pp];

            
            if(pp == 0)continue;//加上这一段就只能打印init

            proc -> children[proc -> childrencount++] = node;

void print_tree(ProcessNode* node, int level,char* prefix) {
    if (node -> childrencount == 0) return;

    for(int i = 0;i < node -> childrencount;i++)
    {   
        
        printf("%s", prefix);//打印前缀
        assert(node -> children[i] != NULL);
         //printf("%s(%d)\n", node->children[i] -> name,node->children[i] -> pid);
        if (level > 0) //如果不是根节点，若是最后一个孩子，则打印└────，否则打印├────
            printf(node -> childrencount == (i + 1) ? "└──── " : "├──── ");
   
        //参数为true时，打印pid
        if (showpid == 1) 
        {
            printf("%s(%d)\n", node->children[i] -> name,node->children[i] -> pid);
        } 
        else 
        {
            printf("%s\n", node->children[i] -> name);
        }

        char new_prefix[MAX_SIZE];
        strncpy(new_prefix, prefix, sizeof(new_prefix) - 1);
        if (level > 0)//如果不是根节点，若是最后一个孩子，则前缀加空格，否则加竖线 
        {
            strcat(new_prefix, node->childrencount == (i + 1) ? "      " : "│     ");
        }

        print_tree(node->children[i], level + 1, new_prefix);//递归打印孩子的孩子节点
    }
 
}

type (*)(....)函数指针 
type (*)[]数组指针

理解复杂声明可用的“右左法则”：
从变量名看起，先往右，再往左，碰到一个圆括号就调转阅读的方向；括号内分析完就跳出括号，还是按先右后左的顺序，如此循环，直到整个声明分析完。举例：
int (*func)(int *p);
首 先找到变量名func，外面有一对圆括号，而且左边是一个*号，这说明func是一个指针；然后跳出这个圆括号，先看右边，又遇到圆括号，这说明 (*func)是一个函数，所以func是一个指向这类函数的指针，即函数指针，这类函数具有int*类型的形参，返回值类型是int。
int (*func[5])(int *);
func 右边是一个[]运算符，说明func是具有5个元素的数组；func的左边有一个*，说明func的元素是指针（注意这里的*不是修饰func，而是修饰 func[5]的，原因是[]运算符优先级比*高，func先跟[]结合）。跳出这个括号，看右边，又遇到圆括号，说明func数组的元素是函数类型的指 针，它指向的函数具有int*类型的形参，返回值类型为int。

bool holding(spinlock_t *lk) {//当前是有锁状态，且锁的拥有者是当前cpu
    return (
        lk->status == LOCKED &&
        lk->cpu == &cpus[cpu_current()]
    );
}

int    printf    (const char *format, ...);