};
 
 /* Socket options:
- * DEBUG       - bitmask of debug message categories
+ * DEBUG       - bitmask of debug message categories (not used)
  * SENDSEQ     - 0 => don't send packets with sequence numbers
  *               1 => send packets with sequence numbers
  * RECVSEQ     - 0 => receive packet sequence numbers are optional
 
        L2TP_ATTR_VLAN_ID,              /* u16 (not used) */
        L2TP_ATTR_COOKIE,               /* 0, 4 or 8 bytes */
        L2TP_ATTR_PEER_COOKIE,          /* 0, 4 or 8 bytes */
-       L2TP_ATTR_DEBUG,                /* u32, enum l2tp_debug_flags */
+       L2TP_ATTR_DEBUG,                /* u32, enum l2tp_debug_flags (not used) */
        L2TP_ATTR_RECV_SEQ,             /* u8 */
        L2TP_ATTR_SEND_SEQ,             /* u8 */
        L2TP_ATTR_LNS_MODE,             /* u8 */
 };
 
 /**
- * enum l2tp_debug_flags - debug message categories for L2TP tunnels/sessions
+ * enum l2tp_debug_flags - debug message categories for L2TP tunnels/sessions.
+ *
+ * Unused.
  *
  * @L2TP_MSG_DEBUG: verbose debug (if compiled in)
  * @L2TP_MSG_CONTROL: userspace - kernel interface
 
        tunnel->version = version;
        tunnel->tunnel_id = tunnel_id;
        tunnel->peer_tunnel_id = peer_tunnel_id;
-       tunnel->debug = L2TP_DEFAULT_DEBUG_FLAGS;
 
        tunnel->magic = L2TP_TUNNEL_MAGIC;
        sprintf(&tunnel->name[0], "tunl %u", tunnel_id);
        rwlock_init(&tunnel->hlist_lock);
        tunnel->acpt_newsess = true;
 
-       if (cfg)
-               tunnel->debug = cfg->debug;
-
        tunnel->encap = encap;
 
        refcount_set(&tunnel->ref_count, 1);
                INIT_HLIST_NODE(&session->hlist);
                INIT_HLIST_NODE(&session->global_hlist);
 
-               /* Inherit debug options from tunnel */
-               session->debug = tunnel->debug;
-
                if (cfg) {
                        session->pwtype = cfg->pw_type;
-                       session->debug = cfg->debug;
                        session->send_seq = cfg->send_seq;
                        session->recv_seq = cfg->recv_seq;
                        session->lns_mode = cfg->lns_mode;
 
        unsigned int            lns_mode:1;     /* behave as LNS?
                                                 * LAC enables sequence numbers under LNS control.
                                                 */
-       int                     debug;          /* bitmask of debug message categories */
        u16                     l2specific_type; /* Layer 2 specific type */
        u8                      cookie[8];      /* optional cookie */
        int                     cookie_len;     /* 0, 4 or 8 bytes */
        unsigned int            lns_mode:1;     /* behave as LNS?
                                                 * LAC enables sequence numbers under LNS control.
                                                 */
-       int                     debug;          /* bitmask of debug message categories */
        int                     reorder_timeout; /* configured reorder timeout (in jiffies) */
        int                     reorder_skip;   /* set if skip to next nr */
        enum l2tp_pwtype        pwtype;
 
 /* L2TP tunnel configuration */
 struct l2tp_tunnel_cfg {
-       int                     debug;          /* bitmask of debug message categories */
        enum l2tp_encap_type    encap;
 
        /* Used only for kernel-created sockets */
        int                     version;        /* 2=>L2TPv2, 3=>L2TPv3 */
 
        char                    name[L2TP_TUNNEL_NAME_MAX]; /* for logging */
-       int                     debug;          /* bitmask of debug message categories */
        enum l2tp_encap_type    encap;
        struct l2tp_stats       stats;
 
 
                   tunnel->sock ? refcount_read(&tunnel->sock->sk_refcnt) : 0,
                   refcount_read(&tunnel->ref_count));
        seq_printf(m, " %08x rx %ld/%ld/%ld rx %ld/%ld/%ld\n",
-                  tunnel->debug,
+                  0,
                   atomic_long_read(&tunnel->stats.tx_packets),
                   atomic_long_read(&tunnel->stats.tx_bytes),
                   atomic_long_read(&tunnel->stats.tx_errors),
                   session->recv_seq ? 'R' : '-',
                   session->send_seq ? 'S' : '-',
                   session->lns_mode ? "LNS" : "LAC",
-                  session->debug,
+                  0,
                   jiffies_to_msecs(session->reorder_timeout));
        seq_printf(m, "   offset 0 l2specific %hu/%hu\n",
                   session->l2specific_type, l2tp_get_l2specific_len(session));
 
                        goto out;
        }
 
-       if (attrs[L2TP_ATTR_DEBUG])
-               cfg.debug = nla_get_u32(attrs[L2TP_ATTR_DEBUG]);
-
        ret = -EINVAL;
        switch (cfg.encap) {
        case L2TP_ENCAPTYPE_UDP:
                goto out;
        }
 
-       if (info->attrs[L2TP_ATTR_DEBUG])
-               tunnel->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
-
        ret = l2tp_tunnel_notify(&l2tp_nl_family, info,
                                 tunnel, L2TP_CMD_TUNNEL_MODIFY);
 
        if (nla_put_u8(skb, L2TP_ATTR_PROTO_VERSION, tunnel->version) ||
            nla_put_u32(skb, L2TP_ATTR_CONN_ID, tunnel->tunnel_id) ||
            nla_put_u32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id) ||
-           nla_put_u32(skb, L2TP_ATTR_DEBUG, tunnel->debug) ||
+           nla_put_u32(skb, L2TP_ATTR_DEBUG, 0) ||
            nla_put_u16(skb, L2TP_ATTR_ENCAP_TYPE, tunnel->encap))
                goto nla_put_failure;
 
                        cfg.ifname = nla_data(info->attrs[L2TP_ATTR_IFNAME]);
        }
 
-       if (info->attrs[L2TP_ATTR_DEBUG])
-               cfg.debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
-
        if (info->attrs[L2TP_ATTR_RECV_SEQ])
                cfg.recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]);
 
                goto out;
        }
 
-       if (info->attrs[L2TP_ATTR_DEBUG])
-               session->debug = nla_get_u32(info->attrs[L2TP_ATTR_DEBUG]);
-
        if (info->attrs[L2TP_ATTR_RECV_SEQ])
                session->recv_seq = nla_get_u8(info->attrs[L2TP_ATTR_RECV_SEQ]);
 
            nla_put_u32(skb, L2TP_ATTR_SESSION_ID, session->session_id) ||
            nla_put_u32(skb, L2TP_ATTR_PEER_CONN_ID, tunnel->peer_tunnel_id) ||
            nla_put_u32(skb, L2TP_ATTR_PEER_SESSION_ID, session->peer_session_id) ||
-           nla_put_u32(skb, L2TP_ATTR_DEBUG, session->debug) ||
+           nla_put_u32(skb, L2TP_ATTR_DEBUG, 0) ||
            nla_put_u16(skb, L2TP_ATTR_PW_TYPE, session->pwtype))
                goto nla_put_failure;
 
 
                if (!tunnel) {
                        struct l2tp_tunnel_cfg tcfg = {
                                .encap = L2TP_ENCAPTYPE_UDP,
-                               .debug = 0,
                        };
 
                        /* Prevent l2tp_tunnel_register() from trying to set up
 
        switch (optname) {
        case PPPOL2TP_SO_DEBUG:
-               tunnel->debug = val;
+               /* Tunnel debug flags option is deprecated */
                break;
 
        default:
                break;
 
        case PPPOL2TP_SO_DEBUG:
-               session->debug = val;
+               /* Session debug flags option is deprecated */
                break;
 
        case PPPOL2TP_SO_REORDERTO:
 
        switch (optname) {
        case PPPOL2TP_SO_DEBUG:
-               *val = tunnel->debug;
+               /* Tunnel debug flags option is deprecated */
+               *val = 0;
                break;
 
        default:
                break;
 
        case PPPOL2TP_SO_DEBUG:
-               *val = session->debug;
+               /* Session debug flags option is deprecated */
+               *val = 0;
                break;
 
        case PPPOL2TP_SO_REORDERTO:
                   (tunnel == tunnel->sock->sk_user_data) ? 'Y' : 'N',
                   refcount_read(&tunnel->ref_count) - 1);
        seq_printf(m, " %08x %ld/%ld/%ld %ld/%ld/%ld\n",
-                  tunnel->debug,
+                  0,
                   atomic_long_read(&tunnel->stats.tx_packets),
                   atomic_long_read(&tunnel->stats.tx_bytes),
                   atomic_long_read(&tunnel->stats.tx_errors),
                   session->recv_seq ? 'R' : '-',
                   session->send_seq ? 'S' : '-',
                   session->lns_mode ? "LNS" : "LAC",
-                  session->debug,
+                  0,
                   jiffies_to_msecs(session->reorder_timeout));
        seq_printf(m, "   %hu/%hu %ld/%ld/%ld %ld/%ld/%ld\n",
                   session->nr, session->ns,