#define SO_TXREHASH            74
 
+#define SO_RCVMARK             75
+
 #if !defined(__KERNEL__)
 
 #if __BITS_PER_LONG == 64
 
 
 #define SO_TXREHASH            74
 
+#define SO_RCVMARK             75
+
 #if !defined(__KERNEL__)
 
 #if __BITS_PER_LONG == 64
 
 
 #define SO_TXREHASH            0x4048
 
+#define SO_RCVMARK             0x4049
+
 #if !defined(__KERNEL__)
 
 #if __BITS_PER_LONG == 64
 
 
 #define SO_TXREHASH              0x0053
 
+#define SO_RCVMARK               0x0054
 
 #if !defined(__KERNEL__)
 
 
        SOCK_TXTIME,
        SOCK_XDP, /* XDP is attached */
        SOCK_TSTAMP_NEW, /* Indicates 64 bit timestamps always */
+       SOCK_RCVMARK, /* Receive SO_MARK  ancillary data with packet */
 };
 
 #define SK_FLAGS_TIMESTAMP ((1UL << SOCK_TIMESTAMP) | (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE))
                __sock_recv_wifi_status(msg, sk, skb);
 }
 
-void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
-                             struct sk_buff *skb);
+void __sock_recv_cmsgs(struct msghdr *msg, struct sock *sk,
+                      struct sk_buff *skb);
 
 #define SK_DEFAULT_STAMP (-1L * NSEC_PER_SEC)
-static inline void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
-                                         struct sk_buff *skb)
+static inline void sock_recv_cmsgs(struct msghdr *msg, struct sock *sk,
+                                  struct sk_buff *skb)
 {
-#define FLAGS_TS_OR_DROPS ((1UL << SOCK_RXQ_OVFL)                      | \
-                          (1UL << SOCK_RCVTSTAMP))
+#define FLAGS_RECV_CMSGS ((1UL << SOCK_RXQ_OVFL)                       | \
+                          (1UL << SOCK_RCVTSTAMP)                      | \
+                          (1UL << SOCK_RCVMARK))
 #define TSFLAGS_ANY      (SOF_TIMESTAMPING_SOFTWARE                    | \
                           SOF_TIMESTAMPING_RAW_HARDWARE)
 
-       if (sk->sk_flags & FLAGS_TS_OR_DROPS || sk->sk_tsflags & TSFLAGS_ANY)
-               __sock_recv_ts_and_drops(msg, sk, skb);
+       if (sk->sk_flags & FLAGS_RECV_CMSGS || sk->sk_tsflags & TSFLAGS_ANY)
+               __sock_recv_cmsgs(msg, sk, skb);
        else if (unlikely(sock_flag(sk, SOCK_TIMESTAMP)))
                sock_write_timestamp(sk, skb->tstamp);
        else if (unlikely(sk->sk_stamp == SK_DEFAULT_STAMP))
 
 
 #define SO_TXREHASH            74
 
+#define SO_RCVMARK             75
+
 #if !defined(__KERNEL__)
 
 #if __BITS_PER_LONG == 64 || (defined(__x86_64__) && defined(__ILP32__))
 
        error = skb_copy_datagram_msg(skb, 0, msg, copied);
        if (error)
                return error;
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        if (!(flags & MSG_PEEK)) {
                pr_debug("%d -= %d\n", atomic_read(&sk->sk_rmem_alloc),
 
        skb_reset_transport_header(skb);
        err = skb_copy_datagram_msg(skb, 0, msg, copied);
        if (err == 0) {
-               sock_recv_ts_and_drops(msg, sk, skb);
+               sock_recv_cmsgs(msg, sk, skb);
 
                if (msg->msg_name && bt_sk(sk)->skb_msg_name)
                        bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
                copied += chunk;
                size   -= chunk;
 
-               sock_recv_ts_and_drops(msg, sk, skb);
+               sock_recv_cmsgs(msg, sk, skb);
 
                if (!(flags & MSG_PEEK)) {
                        int skb_len = skb_headlen(skb);
 
                return err;
        }
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        if (msg->msg_name) {
                __sockaddr_check_size(BCM_MIN_NAMELEN);
 
                paddr->can_addr.j1939.pgn = skcb->addr.pgn;
        }
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
        msg->msg_flags |= skcb->msg_flags;
        skb_free_datagram(sk, skb);
 
 
                return err;
        }
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        if (msg->msg_name) {
                __sockaddr_check_size(RAW_MIN_NAMELEN);
 
 
                __sock_set_mark(sk, val);
                break;
+       case SO_RCVMARK:
+               sock_valbool_flag(sk, SOCK_RCVMARK, valbool);
+               break;
 
        case SO_RXQ_OVFL:
                sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
                v.val = sk->sk_mark;
                break;
 
+       case SO_RCVMARK:
+               v.val = sock_flag(sk, SOCK_RCVMARK);
+               break;
+
        case SO_RXQ_OVFL:
                v.val = sock_flag(sk, SOCK_RXQ_OVFL);
                break;
 
        if (err)
                goto done;
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        if (flags & MSG_TRUNC)
                copied = skb->len;
        if (err)
                goto done;
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        if (saddr) {
                /* Clear the implicit padding in struct sockaddr_ieee802154
 
        if (err)
                goto done;
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        /* Copy the address. */
        if (sin) {
 
                UDP_INC_STATS(sock_net(sk),
                              UDP_MIB_INDATAGRAMS, is_udplite);
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        /* Copy the address. */
        if (sin) {
 
                *addr_len = sizeof(*sin6);
        }
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        if (np->rxopt.all)
                ip6_datagram_recv_ctl(sk, msg, skb);
 
        if (!peeking)
                SNMP_INC_STATS(mib, UDP_MIB_INDATAGRAMS);
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        /* Copy the address. */
        if (msg->msg_name) {
 
        if (err)
                goto out_free;
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        err = (flags & MSG_TRUNC) ? skb->len : copied;
 
 
        if (rc < 0)
                goto out_free;
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        if (addr) {
                struct mctp_skb_cb *cb = mctp_cb(skb);
 
                sll->sll_protocol = skb->protocol;
        }
 
-       sock_recv_ts_and_drops(msg, sk, skb);
+       sock_recv_cmsgs(msg, sk, skb);
 
        if (msg->msg_name) {
                const size_t max_len = min(sizeof(skb->cb),
 
                head_skb = event->chunk->head_skb;
        else
                head_skb = skb;
-       sock_recv_ts_and_drops(msg, sk, head_skb);
+       sock_recv_cmsgs(msg, sk, head_skb);
        if (sctp_ulpevent_is_notification(event)) {
                msg->msg_flags |= MSG_NOTIFICATION;
                sp->pf->event_msgname(event, msg->msg_name, addr_len);
 
                        sizeof(__u32), &SOCK_SKB_CB(skb)->dropcount);
 }
 
-void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
-       struct sk_buff *skb)
+static void sock_recv_mark(struct msghdr *msg, struct sock *sk,
+                          struct sk_buff *skb)
+{
+       if (sock_flag(sk, SOCK_RCVMARK) && skb)
+               put_cmsg(msg, SOL_SOCKET, SO_MARK, sizeof(__u32),
+                        &skb->mark);
+}
+
+void __sock_recv_cmsgs(struct msghdr *msg, struct sock *sk,
+                      struct sk_buff *skb)
 {
        sock_recv_timestamp(msg, sk, skb);
        sock_recv_drops(msg, sk, skb);
+       sock_recv_mark(msg, sk, skb);
 }
-EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops);
+EXPORT_SYMBOL_GPL(__sock_recv_cmsgs);
 
 INDIRECT_CALLABLE_DECLARE(int inet_recvmsg(struct socket *, struct msghdr *,
                                           size_t, int));
 
 
 #define SO_DETACH_REUSEPORT_BPF 68
 
+#define SO_RCVMARK             75
+
 #if !defined(__KERNEL__)
 
 #if __BITS_PER_LONG == 64 || (defined(__x86_64__) && defined(__ILP32__))