426         struct cfs_rq cfs;
427         struct rt_rq rt;

30 /* Standard interface flags (netdevice->flags). */
31 #define IFF_UP          0x1             /* interface is up              */
32 #define IFF_BROADCAST   0x2             /* broadcast address valid      */
33 #define IFF_DEBUG       0x4             /* turn on debugging            */
34 #define IFF_LOOPBACK    0x8             /* is a loopback net            */
35 #define IFF_POINTOPOINT 0x10            /* interface is has p-p link    */
36 #define IFF_NOTRAILERS  0x20            /* avoid use of trailers        */
37 #define IFF_RUNNING     0x40            /* interface RFC2863 OPER_UP    */
38 #define IFF_NOARP       0x80            /* no ARP protocol              */
39 #define IFF_PROMISC     0x100           /* receive all packets          */
40 #define IFF_ALLMULTI    0x200           /* receive all multicast packets*/
...

/**
 *      register_pernet_subsys - register a network namespace subsystem
 *    @ops:  pernet operations structure for the subsystem
 *
 *    Register a subsystem which has init and exit functions
 *    that are called when network namespaces are created and
 *    destroyed respectively.
 *
 *    When registered all network namespace init functions are
 *    called for every existing network namespace.  Allowing kernel
 *    modules to have a race free view of the set of network namespaces.
 *
 *    When a new network namespace is created all of the init
 *    methods are called in the order in which they were registered.
 *
 *    When a network namespace is destroyed all of the exit methods
 *    are called in the reverse of the order with which they were
 *    registered.
 */

int register_pernet_subsys(struct pernet_operations *ops)
{
    int error;
    mutex_lock(&net_mutex);
    error =  register_pernet_operations(first_device, ops);
    mutex_unlock(&net_mutex);
    return error;
}
===>static int register_pernet_operations(struct list_head *list,
                  struct pernet_operations *ops)
{
    error = __register_pernet_operations(list, ops);
}

======>#ifdef CONFIG_NET_NS
static int __register_pernet_operations(struct list_head *list,
                    struct pernet_operations *ops)
    LIST_HEAD(net_exit_list);

    list_add_tail(&ops->list, list);
    if (ops->init || (ops->id && ops->size)) {
        for_each_net(net) {
            error = ops_init(ops, net);
            if (error)
                goto out_undo;
            list_add_tail(&net->exit_list, &net_exit_list);
        }
    }
    return 0;


========>#ifdef CONFIG_NET_NS
    static int __register_pernet_operations(struct list_head *list,
                    struct pernet_operations *ops)
    struct net *net;
    int error;
    LIST_HEAD(net_exit_list);
 
    list_add_tail(&ops->list, list);
    if (ops->init || (ops->id && ops->size)) {
        for_each_net(net) {
=============>            error = ops_init(ops, net);
            if (error)
                goto out_undo;
=============>        list_add_tail(&net->exit_list, &net_exit_list);<<< confused?!!! net_exit_list局部变量？

        }
    }
    return 0;


=============>static int ops_init(const struct pernet_operations *ops, struct net *net)
{
    int err;
    if (ops->id && ops->size) {
        void *data = kzalloc(ops->size, GFP_KERNEL);
        if (!data)
            return -ENOMEM;
 
        err = net_assign_generic(net, *ops->id, data);
        if (err) {
            kfree(data);
            return err;
        }
    }
    if (ops->init)
        return ops->init(net);<====== the ops->init will be called.
    return 0;
}

static struct pernet_operations inet6_net_ops = { 
    .init = inet6_net_init, 
    .exit = inet6_net_exit, 
};
static int __init inet6_init(void) 
{ 
.....
    err = register_pernet_subsys(&inet6_net_ops); 
    if (err) 
        goto register_pernet_fail; 
.....
}
call:     ops->init(net);<====== the ops->init will be called.
equal with =======   .init = inet6_net_init,
                     inet6_net_init(net);

 93 struct netlink_callback {
 94         struct sk_buff          *skb;
 95         const struct nlmsghdr   *nlh;
 96         int                     (*dump)(struct sk_buff * skb,
 97                                         struct netlink_callback *cb);
 98         int                     (*done)(struct netlink_callback *cb);
 99         void                    *data;
100         /* the module that dump function belong to */
101         struct module           *module;
102         u16                     family;
103         u16                     min_dump_alloc;
104         unsigned int            prev_seq, seq;
105         long                    args[6];
106 };

117 struct netlink_dump_control {
118         int (*dump)(struct sk_buff *skb, struct netlink_callback *);
119         int (*done)(struct netlink_callback *);
120         void *data;
121         struct module *module;
122         u16 min_dump_alloc;
123 };