#include <linux/filter.h>
 #include <linux/rculist_nulls.h>
 #include <linux/poll.h>
+#include <linux/sockptr.h>
 
 #include <linux/atomic.h>
 #include <linux/refcount.h>
 #endif
 
 int sock_setsockopt(struct socket *sock, int level, int op,
-                   char __user *optval, unsigned int optlen);
+                   sockptr_t optval, unsigned int optlen);
 
 int sock_getsockopt(struct socket *sock, int level, int op,
                    char __user *optval, int __user *optlen);
 
  */
 
 int sock_setsockopt(struct socket *sock, int level, int optname,
-                   char __user *optval, unsigned int optlen)
+                   sockptr_t optval, unsigned int optlen)
 {
        struct sock_txtime sk_txtime;
        struct sock *sk = sock->sk;
         */
 
        if (optname == SO_BINDTODEVICE)
-               return sock_setbindtodevice(sk, USER_SOCKPTR(optval), optlen);
+               return sock_setbindtodevice(sk, optval, optlen);
 
        if (optlen < sizeof(int))
                return -EINVAL;
 
-       if (get_user(val, (int __user *)optval))
+       if (copy_from_sockptr(&val, optval, sizeof(val)))
                return -EFAULT;
 
        valbool = val ? 1 : 0;
                        ret = -EINVAL;  /* 1003.1g */
                        break;
                }
-               if (copy_from_user(&ling, optval, sizeof(ling))) {
+               if (copy_from_sockptr(&ling, optval, sizeof(ling))) {
                        ret = -EFAULT;
                        break;
                }
 
        case SO_RCVTIMEO_OLD:
        case SO_RCVTIMEO_NEW:
-               ret = sock_set_timeout(&sk->sk_rcvtimeo, USER_SOCKPTR(optval),
+               ret = sock_set_timeout(&sk->sk_rcvtimeo, optval,
                                       optlen, optname == SO_RCVTIMEO_OLD);
                break;
 
        case SO_SNDTIMEO_OLD:
        case SO_SNDTIMEO_NEW:
-               ret = sock_set_timeout(&sk->sk_sndtimeo, USER_SOCKPTR(optval),
+               ret = sock_set_timeout(&sk->sk_sndtimeo, optval,
                                       optlen, optname == SO_SNDTIMEO_OLD);
                break;
 
        case SO_ATTACH_FILTER: {
                struct sock_fprog fprog;
 
-               ret = copy_bpf_fprog_from_user(&fprog, USER_SOCKPTR(optval),
-                                              optlen);
+               ret = copy_bpf_fprog_from_user(&fprog, optval, optlen);
                if (!ret)
                        ret = sk_attach_filter(&fprog, sk);
                break;
                        u32 ufd;
 
                        ret = -EFAULT;
-                       if (copy_from_user(&ufd, optval, sizeof(ufd)))
+                       if (copy_from_sockptr(&ufd, optval, sizeof(ufd)))
                                break;
 
                        ret = sk_attach_bpf(ufd, sk);
        case SO_ATTACH_REUSEPORT_CBPF: {
                struct sock_fprog fprog;
 
-               ret = copy_bpf_fprog_from_user(&fprog, USER_SOCKPTR(optval),
-                                              optlen);
+               ret = copy_bpf_fprog_from_user(&fprog, optval, optlen);
                if (!ret)
                        ret = sk_reuseport_attach_filter(&fprog, sk);
                break;
                        u32 ufd;
 
                        ret = -EFAULT;
-                       if (copy_from_user(&ufd, optval, sizeof(ufd)))
+                       if (copy_from_sockptr(&ufd, optval, sizeof(ufd)))
                                break;
 
                        ret = sk_reuseport_attach_bpf(ufd, sk);
 
                if (sizeof(ulval) != sizeof(val) &&
                    optlen >= sizeof(ulval) &&
-                   get_user(ulval, (unsigned long __user *)optval)) {
+                   copy_from_sockptr(&ulval, optval, sizeof(ulval))) {
                        ret = -EFAULT;
                        break;
                }
                if (optlen != sizeof(struct sock_txtime)) {
                        ret = -EINVAL;
                        break;
-               } else if (copy_from_user(&sk_txtime, optval,
+               } else if (copy_from_sockptr(&sk_txtime, optval,
                           sizeof(struct sock_txtime))) {
                        ret = -EFAULT;
                        break;
 
                        return -EINVAL;
                }
 
-               ret = sock_setsockopt(ssock, SOL_SOCKET, optname, optval, optlen);
+               ret = sock_setsockopt(ssock, SOL_SOCKET, optname,
+                                     USER_SOCKPTR(optval), optlen);
                if (ret == 0) {
                        if (optname == SO_REUSEPORT)
                                sk->sk_reuseport = ssock->sk->sk_reuseport;
                return ret;
        }
 
-       return sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname, optval, optlen);
+       return sock_setsockopt(sk->sk_socket, SOL_SOCKET, optname,
+                              USER_SOCKPTR(optval), optlen);
 }
 
 static int mptcp_setsockopt_v6(struct mptcp_sock *msk, int optname,