static void fcoe_dcb_create(struct fcoe_interface *fcoe)

{

#ifdef CONFIG_DCB

     int dcbx;

   u8 fup, up;

   struct net_device *netdev = fcoe->realdev;

   struct fcoe_port *port = lport_priv(fcoe->ctlr.lp);

         struct dcb_app app = {

                                 .priority = 0,

                        .protocol = ETH_P_FCOE

                        };

    ...

                        app.selector = DCB_APP_IDTYPE_ETHTYPE;

                    up = dcb_getapp(netdev, &app);

                       app.protocol = ETH_P_FIP;

               fup = dcb_getapp(netdev, &app);

              }

                 port->priority = ffs(up) ? ffs(up) - 1 : 0;

fcoe->ctlr.priority = ffs(fup) ? ffs(fup) - 1 : port->priority;

static int __init netlink_proto_init(void)

         sock_register(&netlink_family_ops);

}

static const struct net_proto_familynetlink_family_ops = {

       .family = PF_NETLINK,

       .create = netlink_create,

       .owner    = THIS_MODULE, /* for consistency 8) */

};

在netlink_create中调用

static int __netlink_create(struct net *net, struct socket *sock,

                         struct mutex *cb_mutex, int protocol)

{

       struct sock *sk;

       struct netlink_sock *nlk;

       sock->ops = &netlink_ops;

       sk = sk_alloc(net, PF_NETLINK, GFP_KERNEL, &netlink_proto);

       …

}

static const struct proto_opsnetlink_ops= {

       .family = PF_NETLINK,

       .owner = THIS_MODULE,

       .release =      netlink_release,

       .bind =          netlink_bind,

       .connect =     netlink_connect,

       .socketpair = sock_no_socketpair,

       .accept =       sock_no_accept,

       .getname =    netlink_getname,

       .poll =           datagram_poll,

       .ioctl =   sock_no_ioctl,

       .listen =  sock_no_listen,

       .shutdown =  sock_no_shutdown,

       .setsockopt =       netlink_setsockopt,

       .getsockopt =       netlink_getsockopt,

       .sendmsg =   netlink_sendmsg,//这可能就是和那些系统调用对应的函数

       .recvmsg =    netlink_recvmsg,

       .mmap =              sock_no_mmap,

       .sendpage =  sock_no_sendpage,

};

static int __init netlink_proto_init(void)

         sock_register(&netlink_family_ops);

}

static const struct net_proto_familynetlink_family_ops = {

       .family = PF_NETLINK,

       .create = netlink_create,

       .owner    = THIS_MODULE, /* for consistency 8) */

};

在netlink_create中调用

static int __netlink_create(struct net *net, struct socket *sock,

                         struct mutex *cb_mutex, int protocol)

{

       struct sock *sk;

       struct netlink_sock *nlk;

       sock->ops = &netlink_ops;

       sk = sk_alloc(net, PF_NETLINK, GFP_KERNEL, &netlink_proto);

       …

}

static const struct proto_opsnetlink_ops= {

       .family = PF_NETLINK,

       .owner = THIS_MODULE,

       .release =      netlink_release,

       .bind =          netlink_bind,

       .connect =     netlink_connect,

       .socketpair = sock_no_socketpair,

       .accept =       sock_no_accept,

       .getname =    netlink_getname,

       .poll =           datagram_poll,

       .ioctl =   sock_no_ioctl,

       .listen =  sock_no_listen,

       .shutdown =  sock_no_shutdown,

       .setsockopt =       netlink_setsockopt,

       .getsockopt =       netlink_getsockopt,

       .sendmsg =   netlink_sendmsg,//这可能就是和那些系统调用对应的函数

       .recvmsg =    netlink_recvmsg,

       .mmap =              sock_no_mmap,

       .sendpage =  sock_no_sendpage,

};

/**

 * enum dcbnl_attrs - DCB top-level netlink attributes

 *

 * @DCB_ATTR_UNDEFINED: unspecified attribute to catch errors

 * @DCB_ATTR_IFNAME: interface name of the underlying device (NLA_STRING)

 * @DCB_ATTR_STATE: enable state of DCB in the device (NLA_U8)

 * @DCB_ATTR_PFC_STATE: enable state of PFC in the device (NLA_U8)

 * @DCB_ATTR_PFC_CFG: priority flow control configuration (NLA_NESTED)

 * @DCB_ATTR_NUM_TC: number of traffic classes supported in the device (NLA_U8)

 * @DCB_ATTR_PG_CFG: priority group configuration (NLA_NESTED)

 * @DCB_ATTR_SET_ALL: bool to commit changes to hardware or not (NLA_U8)

 * @DCB_ATTR_PERM_HWADDR: MAC address of the physical device (NLA_NESTED)

 * @DCB_ATTR_CAP: DCB capabilities of the device (NLA_NESTED)

 * @DCB_ATTR_NUMTCS: number of traffic classes supported (NLA_NESTED)

 * @DCB_ATTR_BCN: backward congestion notification configuration (NLA_NESTED)

 * @DCB_ATTR_IEEE: IEEE 802.1Qaz supported attributes (NLA_NESTED)

 * @DCB_ATTR_DCBX: DCBX engine configuration in the device (NLA_U8)

 * @DCB_ATTR_FEATCFG: DCBX features flags (NLA_NESTED)

 * @DCB_ATTR_CEE: CEE std supported attributes (NLA_NESTED)

 */

struct nlattr {

         __u16           nla_len;

         __u16           nla_type;

};

struct nlmsghdr {

         __u32                nlmsg_len;       /* Length of message including header */

         __u16                nlmsg_type;     /* Message content */

         __u16                nlmsg_flags;    /* Additional flags */

         __u32                nlmsg_seq;      /* Sequence number */

         __u32                nlmsg_pid;       /* Sending process port ID */

};

/* DCB netlink attributes policy */

static const struct nla_policy dcbnl_rtnl_policy[DCB_ATTR_MAX + 1] = {

         [DCB_ATTR_IFNAME]      = {.type = NLA_NUL_STRING, .len = IFNAMSIZ - 1},

         [DCB_ATTR_STATE]       = {.type = NLA_U8},

         [DCB_ATTR_PFC_CFG]     = {.type = NLA_NESTED},

         [DCB_ATTR_PG_CFG]      = {.type = NLA_NESTED},

         [DCB_ATTR_SET_ALL]     = {.type = NLA_U8},

         [DCB_ATTR_PERM_HWADDR] = {.type = NLA_FLAG},

         [DCB_ATTR_CAP]         = {.type = NLA_NESTED},

         [DCB_ATTR_PFC_STATE]   = {.type = NLA_U8},

         [DCB_ATTR_BCN]         = {.type = NLA_NESTED},

         [DCB_ATTR_APP]         = {.type = NLA_NESTED},

         [DCB_ATTR_IEEE]           = {.type = NLA_NESTED},

         [DCB_ATTR_DCBX]        = {.type = NLA_U8},

         [DCB_ATTR_FEATCFG]     = {.type = NLA_NESTED},

};

/**

 * nlmsg_parse - parse attributes of a netlink message

 * @nlh: netlink message header

 * @hdrlen: length of family specific header

 * @tb: destination array with maxtype+1 elements

 * @maxtype: maximum attribute type to be expected

 * @policy: validation policy

 *

 * See nla_parse()

 */

static inline int nlmsg_parse(const struct nlmsghdr *nlh, int hdrlen,

                           struct nlattr *tb[], int maxtype,

                           const struct nla_policy *policy)

{

       if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))

              return -EINVAL;

       return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),

                      nlmsg_attrlen(nlh, hdrlen), policy);

}

Parses a stream of attributes and stores a pointer to each attribute in

 * the tb array accessible via the attribute type. Attributes with a type

 * exceeding maxtype will be silently ignored for backwards compatibility

 * reasons. policy may be set to NULL if no validation is required.

 *

 * Returns 0 on success or a negative error code.

 */

int nla_parse(struct nlattr **tb, int maxtype, const struct nlattr *head,

             int len, const struct nla_policy *policy)

{

       const struct nlattr *nla;

       int rem, err;

       memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));

       nla_for_each_attr(nla, head, len, rem) {

              u16 type = nla_type(nla);

              if (type > 0 && type <= maxtype) {

                     if (policy) {

                            err = validate_nla(nla, maxtype, policy);

                            if (err < 0)

                                   goto errout;

                     }

                     tb[type] = (struct nlattr *)nla;

              }

       }

struct dcbmsg {

       __u8               dcb_family;

       __u8               cmd;

       __u16              dcb_pad;

};

命令包括：

/**

 * enum dcbnl_commands - supported DCB commands

 *

 * @DCB_CMD_UNDEFINED: unspecified command to catch errors

 * @DCB_CMD_GSTATE: request the state of DCB in the device

 * @DCB_CMD_SSTATE: set the state of DCB in the device

 * @DCB_CMD_PGTX_GCFG: request the priority group configuration for Tx

 * @DCB_CMD_PGTX_SCFG: set the priority group configuration for Tx

 * @DCB_CMD_PGRX_GCFG: request the priority group configuration for Rx

 * @DCB_CMD_PGRX_SCFG: set the priority group configuration for Rx

 * @DCB_CMD_PFC_GCFG: request the priority flow control configuration

 * @DCB_CMD_PFC_SCFG: set the priority flow control configuration

 * @DCB_CMD_SET_ALL: apply all changes to the underlying device

 * @DCB_CMD_GPERM_HWADDR: get the permanent MAC address of the underlying

 *                        device.  Only useful when using bonding.

 * @DCB_CMD_GCAP: request the DCB capabilities of the device

 * @DCB_CMD_GNUMTCS: get the number of traffic classes currently supported

 * @DCB_CMD_SNUMTCS: set the number of traffic classes

 * @DCB_CMD_GBCN: set backward congestion notification configuration

 * @DCB_CMD_SBCN: get backward congestion notification configration.

 * @DCB_CMD_GAPP: get application protocol configuration

 * @DCB_CMD_SAPP: set application protocol configuration

 * @DCB_CMD_IEEE_SET: set IEEE 802.1Qaz configuration

 * @DCB_CMD_IEEE_GET: get IEEE 802.1Qaz configuration

 * @DCB_CMD_GDCBX: get DCBX engine configuration

 * @DCB_CMD_SDCBX: set DCBX engine configuration

 * @DCB_CMD_GFEATCFG: get DCBX features flags

 * @DCB_CMD_SFEATCFG: set DCBX features negotiation flags

 * @DCB_CMD_CEE_GET: get CEE aggregated configuration

 * @DCB_CMD_IEEE_DEL: delete IEEE 802.1Qaz configuration

 */

static int dcbnl_reply(u8 value, u8 event, u8 cmd, u8 attr, u32 pid,

                       u32 seq, u16 flags)

{

         struct sk_buff *dcbnl_skb;

         struct dcbmsg *dcb;

         struct nlmsghdr *nlh;

         int ret = -EINVAL

         dcbnl_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);

         if (!dcbnl_skb)

                   return ret;

         nlh = NLMSG_NEW(dcbnl_skb, pid, seq, event, sizeof(*dcb), flags);

         dcb = NLMSG_DATA(nlh);

         dcb->dcb_family = AF_UNSPEC;

         dcb->cmd = cmd;

         dcb->dcb_pad = 0;

         ret = nla_put_u8(dcbnl_skb, attr, value);

         if (ret)

                   goto err;

         /* end the message, assign the nlmsg_len. */

         nlmsg_end(dcbnl_skb, nlh);

         ret = rtnl_unicast(dcbnl_skb, &init_net, pid);