17 files changed, 56 insertions, 46 deletions

diff --git a/net/9p/client.c b/net/9p/client.c
index 4b529454616d..821f1ec0b2c3 100644
--- a/net/9p/client.c
+++ b/net/9p/client.c
@@ -627,7 +627,7 @@ static struct p9_fid *p9_fid_create(struct p9_client *clnt)
         memset(&fid->qid, 0, sizeof(struct p9_qid));
         fid->mode = -1;
         fid->rdir_fpos = 0;
-        fid->uid = current->fsuid;
+        fid->uid = current_fsuid();
         fid->clnt = clnt;
         fid->aux = NULL;
 
diff --git a/net/ax25/af_ax25.c b/net/ax25/af_ax25.c
index 28c71574a781..00d9e5e13158 100644
--- a/net/ax25/af_ax25.c
+++ b/net/ax25/af_ax25.c
@@ -1045,7 +1045,7 @@ static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
         if (addr->fsa_ax25.sax25_family != AF_AX25)
                 return -EINVAL;
 
-        user = ax25_findbyuid(current->euid);
+        user = ax25_findbyuid(current_euid());
         if (user) {
                 call = user->call;
                 ax25_uid_put(user);
diff --git a/net/ax25/ax25_route.c b/net/ax25/ax25_route.c
index 8672cd84fdf9..c833ba4c45a5 100644
--- a/net/ax25/ax25_route.c
+++ b/net/ax25/ax25_route.c
@@ -421,7 +421,7 @@ int ax25_rt_autobind(ax25_cb *ax25, ax25_address *addr)
                 goto put;
         }
 
-        user = ax25_findbyuid(current->euid);
+        user = ax25_findbyuid(current_euid());
         if (user) {
                 ax25->source_addr = user->call;
                 ax25_uid_put(user);
diff --git a/net/core/dev.c b/net/core/dev.c
index 9174c77d3112..89912ae6de65 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -2961,6 +2961,8 @@ static void dev_change_rx_flags(struct net_device *dev, int flags)
 static int __dev_set_promiscuity(struct net_device *dev, int inc)
 {
         unsigned short old_flags = dev->flags;
+        uid_t uid;
+        gid_t gid;
 
         ASSERT_RTNL();
 
@@ -2985,15 +2987,17 @@ static int __dev_set_promiscuity(struct net_device *dev, int inc)
                 printk(KERN_INFO "device %s %s promiscuous mode\n",
                        dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
                                                                "left");
-                if (audit_enabled)
+                if (audit_enabled) {
+                        current_uid_gid(&uid, &gid);
                         audit_log(current->audit_context, GFP_ATOMIC,
                                 AUDIT_ANOM_PROMISCUOUS,
                                 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
                                 dev->name, (dev->flags & IFF_PROMISC),
                                 (old_flags & IFF_PROMISC),
                                 audit_get_loginuid(current),
-                                current->uid, current->gid,
+                                uid, gid,
                                 audit_get_sessionid(current));
+                }
 
                 dev_change_rx_flags(dev, IFF_PROMISC);
         }
diff --git a/net/core/scm.c b/net/core/scm.c
index b12303dd39d9..b7ba91b074b3 100644
--- a/net/core/scm.c
+++ b/net/core/scm.c
@@ -44,11 +44,13 @@
 
 static __inline__ int scm_check_creds(struct ucred *creds)
 {
+        const struct cred *cred = current_cred();
+
         if ((creds->pid == task_tgid_vnr(current) || capable(CAP_SYS_ADMIN)) &&
-            ((creds->uid == current->uid || creds->uid == current->euid ||
-              creds->uid == current->suid) || capable(CAP_SETUID)) &&
-            ((creds->gid == current->gid || creds->gid == current->egid ||
-              creds->gid == current->sgid) || capable(CAP_SETGID))) {
+            ((creds->uid == cred->uid   || creds->uid == cred->euid ||
+              creds->uid == cred->suid) || capable(CAP_SETUID)) &&
+            ((creds->gid == cred->gid   || creds->gid == cred->egid ||
+              creds->gid == cred->sgid) || capable(CAP_SETGID))) {
                return 0;
         }
         return -EPERM;
diff --git a/net/ipv4/netfilter/ipt_LOG.c b/net/ipv4/netfilter/ipt_LOG.c
index fc6ce04a3e35..7b5dbe118c09 100644
--- a/net/ipv4/netfilter/ipt_LOG.c
+++ b/net/ipv4/netfilter/ipt_LOG.c
@@ -340,8 +340,8 @@ static void dump_packet(const struct nf_loginfo *info,
                 read_lock_bh(&skb->sk->sk_callback_lock);
                 if (skb->sk->sk_socket && skb->sk->sk_socket->file)
                         printk("UID=%u GID=%u ",
-                                skb->sk->sk_socket->file->f_uid,
-                                skb->sk->sk_socket->file->f_gid);
+                                skb->sk->sk_socket->file->f_cred->fsuid,
+                                skb->sk->sk_socket->file->f_cred->fsgid);
                 read_unlock_bh(&skb->sk->sk_callback_lock);
         }
 
diff --git a/net/ipv6/ip6_flowlabel.c b/net/ipv6/ip6_flowlabel.c
index 37a4e777e347..bd3c7b96bbaa 100644
--- a/net/ipv6/ip6_flowlabel.c
+++ b/net/ipv6/ip6_flowlabel.c
@@ -388,7 +388,7 @@ fl_create(struct net *net, struct in6_flowlabel_req *freq, char __user *optval,
                 fl->owner = current->pid;
                 break;
         case IPV6_FL_S_USER:
-                fl->owner = current->euid;
+                fl->owner = current_euid();
                 break;
         default:
                 err = -EINVAL;
diff --git a/net/ipv6/netfilter/ip6t_LOG.c b/net/ipv6/netfilter/ip6t_LOG.c
index caa441d09567..871d157cec4e 100644
--- a/net/ipv6/netfilter/ip6t_LOG.c
+++ b/net/ipv6/netfilter/ip6t_LOG.c
@@ -364,8 +364,8 @@ static void dump_packet(const struct nf_loginfo *info,
                 read_lock_bh(&skb->sk->sk_callback_lock);
                 if (skb->sk->sk_socket && skb->sk->sk_socket->file)
                         printk("UID=%u GID=%u ",
-                                skb->sk->sk_socket->file->f_uid,
-                                skb->sk->sk_socket->file->f_gid);
+                                skb->sk->sk_socket->file->f_cred->fsuid,
+                                skb->sk->sk_socket->file->f_cred->fsgid);
                 read_unlock_bh(&skb->sk->sk_callback_lock);
         }
 
diff --git a/net/netfilter/nfnetlink_log.c b/net/netfilter/nfnetlink_log.c
index 41e0105d3828..38f9efd90e8d 100644
--- a/net/netfilter/nfnetlink_log.c
+++ b/net/netfilter/nfnetlink_log.c
@@ -474,8 +474,9 @@ __build_packet_message(struct nfulnl_instance *inst,
         if (skb->sk) {
                 read_lock_bh(&skb->sk->sk_callback_lock);
                 if (skb->sk->sk_socket && skb->sk->sk_socket->file) {
-                        __be32 uid = htonl(skb->sk->sk_socket->file->f_uid);
-                        __be32 gid = htonl(skb->sk->sk_socket->file->f_gid);
+                        struct file *file = skb->sk->sk_socket->file;
+                        __be32 uid = htonl(file->f_cred->fsuid);
+                        __be32 gid = htonl(file->f_cred->fsgid);
                         /* need to unlock here since NLA_PUT may goto */
                         read_unlock_bh(&skb->sk->sk_callback_lock);
                         NLA_PUT_BE32(inst->skb, NFULA_UID, uid);
diff --git a/net/netfilter/xt_owner.c b/net/netfilter/xt_owner.c
index f19ebd9b78f5..22b2a5e881ea 100644
--- a/net/netfilter/xt_owner.c
+++ b/net/netfilter/xt_owner.c
@@ -34,12 +34,12 @@ owner_mt_v0(const struct sk_buff *skb, const struct xt_match_param *par)
                 return false;
 
         if (info->match & IPT_OWNER_UID)
-                if ((filp->f_uid != info->uid) ^
+                if ((filp->f_cred->fsuid != info->uid) ^
                     !!(info->invert & IPT_OWNER_UID))
                         return false;
 
         if (info->match & IPT_OWNER_GID)
-                if ((filp->f_gid != info->gid) ^
+                if ((filp->f_cred->fsgid != info->gid) ^
                     !!(info->invert & IPT_OWNER_GID))
                         return false;
 
@@ -60,12 +60,12 @@ owner_mt6_v0(const struct sk_buff *skb, const struct xt_match_param *par)
                 return false;
 
         if (info->match & IP6T_OWNER_UID)
-                if ((filp->f_uid != info->uid) ^
+                if ((filp->f_cred->fsuid != info->uid) ^
                     !!(info->invert & IP6T_OWNER_UID))
                         return false;
 
         if (info->match & IP6T_OWNER_GID)
-                if ((filp->f_gid != info->gid) ^
+                if ((filp->f_cred->fsgid != info->gid) ^
                     !!(info->invert & IP6T_OWNER_GID))
                         return false;
 
@@ -93,14 +93,14 @@ owner_mt(const struct sk_buff *skb, const struct xt_match_param *par)
                        (XT_OWNER_UID | XT_OWNER_GID)) == 0;
 
         if (info->match & XT_OWNER_UID)
-                if ((filp->f_uid >= info->uid_min &&
-                    filp->f_uid <= info->uid_max) ^
+                if ((filp->f_cred->fsuid >= info->uid_min &&
+                    filp->f_cred->fsuid <= info->uid_max) ^
                     !(info->invert & XT_OWNER_UID))
                         return false;
 
         if (info->match & XT_OWNER_GID)
-                if ((filp->f_gid >= info->gid_min &&
-                    filp->f_gid <= info->gid_max) ^
+                if ((filp->f_cred->fsgid >= info->gid_min &&
+                    filp->f_cred->fsgid <= info->gid_max) ^
                     !(info->invert & XT_OWNER_GID))
                         return false;
 
diff --git a/net/netrom/af_netrom.c b/net/netrom/af_netrom.c
index 9f1ea4a27b35..e9c05b8f4f45 100644
--- a/net/netrom/af_netrom.c
+++ b/net/netrom/af_netrom.c
@@ -609,7 +609,7 @@ static int nr_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
         } else {
                 source = &addr->fsa_ax25.sax25_call;
 
-                user = ax25_findbyuid(current->euid);
+                user = ax25_findbyuid(current_euid());
                 if (user) {
                         nr->user_addr   = user->call;
                         ax25_uid_put(user);
@@ -683,7 +683,7 @@ static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
                 }
                 source = (ax25_address *)dev->dev_addr;
 
-                user = ax25_findbyuid(current->euid);
+                user = ax25_findbyuid(current_euid());
                 if (user) {
                         nr->user_addr   = user->call;
                         ax25_uid_put(user);
diff --git a/net/rose/af_rose.c b/net/rose/af_rose.c
index 0c1cc7612800..01392649b462 100644
--- a/net/rose/af_rose.c
+++ b/net/rose/af_rose.c
@@ -690,7 +690,7 @@ static int rose_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 
         source = &addr->srose_call;
 
-        user = ax25_findbyuid(current->euid);
+        user = ax25_findbyuid(current_euid());
         if (user) {
                 rose->source_call = user->call;
                 ax25_uid_put(user);
@@ -791,7 +791,7 @@ static int rose_connect(struct socket *sock, struct sockaddr *uaddr, int addr_le
                         goto out_release;
                 }
 
-                user = ax25_findbyuid(current->euid);
+                user = ax25_findbyuid(current_euid());
                 if (!user) {
                         err = -EINVAL;
                         goto out_release;
diff --git a/net/rxrpc/ar-key.c b/net/rxrpc/ar-key.c
index 9a8ff684da79..ad8c7a782da1 100644
--- a/net/rxrpc/ar-key.c
+++ b/net/rxrpc/ar-key.c
@@ -287,6 +287,7 @@ int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
                               time_t expiry,
                               u32 kvno)
 {
+        const struct cred *cred = current_cred();
         struct key *key;
         int ret;
 
@@ -297,7 +298,7 @@ int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
 
         _enter("");
 
-        key = key_alloc(&key_type_rxrpc, "x", 0, 0, current, 0,
+        key = key_alloc(&key_type_rxrpc, "x", 0, 0, cred, 0,
                         KEY_ALLOC_NOT_IN_QUOTA);
         if (IS_ERR(key)) {
                 _leave(" = -ENOMEM [alloc %ld]", PTR_ERR(key));
@@ -340,10 +341,11 @@ EXPORT_SYMBOL(rxrpc_get_server_data_key);
  */
 struct key *rxrpc_get_null_key(const char *keyname)
 {
+        const struct cred *cred = current_cred();
         struct key *key;
         int ret;
 
-        key = key_alloc(&key_type_rxrpc, keyname, 0, 0, current,
+        key = key_alloc(&key_type_rxrpc, keyname, 0, 0, cred,
                         KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA);
         if (IS_ERR(key))
                 return key;
diff --git a/net/sched/cls_flow.c b/net/sched/cls_flow.c
index 0ebaff637e31..0ef4e3065bcd 100644
--- a/net/sched/cls_flow.c
+++ b/net/sched/cls_flow.c
@@ -260,14 +260,14 @@ static u32 flow_get_rtclassid(const struct sk_buff *skb)
 static u32 flow_get_skuid(const struct sk_buff *skb)
 {
         if (skb->sk && skb->sk->sk_socket && skb->sk->sk_socket->file)
-                return skb->sk->sk_socket->file->f_uid;
+                return skb->sk->sk_socket->file->f_cred->fsuid;
         return 0;
 }
 
 static u32 flow_get_skgid(const struct sk_buff *skb)
 {
         if (skb->sk && skb->sk->sk_socket && skb->sk->sk_socket->file)
-                return skb->sk->sk_socket->file->f_gid;
+                return skb->sk->sk_socket->file->f_cred->fsgid;
         return 0;
 }
 
diff --git a/net/socket.c b/net/socket.c
index 92764d836891..b7a562e655e9 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -491,8 +491,8 @@ static struct socket *sock_alloc(void)
         sock = SOCKET_I(inode);
 
         inode->i_mode = S_IFSOCK | S_IRWXUGO;
-        inode->i_uid = current->fsuid;
-        inode->i_gid = current->fsgid;
+        inode->i_uid = current_fsuid();
+        inode->i_gid = current_fsgid();
 
         get_cpu_var(sockets_in_use)++;
         put_cpu_var(sockets_in_use);
diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
index cb216b2df666..0443f8349458 100644
--- a/net/sunrpc/auth.c
+++ b/net/sunrpc/auth.c
@@ -350,16 +350,18 @@ EXPORT_SYMBOL_GPL(rpcauth_lookup_credcache);
 struct rpc_cred *
 rpcauth_lookupcred(struct rpc_auth *auth, int flags)
 {
-        struct auth_cred acred = {
-                .uid = current->fsuid,
-                .gid = current->fsgid,
-                .group_info = current->group_info,
-        };
+        struct auth_cred acred;
         struct rpc_cred *ret;
+        const struct cred *cred = current_cred();
 
         dprintk("RPC:       looking up %s cred\n",
                 auth->au_ops->au_name);
-        get_group_info(acred.group_info);
+
+        memset(&acred, 0, sizeof(acred));
+        acred.uid = cred->fsuid;
+        acred.gid = cred->fsgid;
+        acred.group_info = get_group_info(((struct cred *)cred)->group_info);
+
         ret = auth->au_ops->lookup_cred(auth, &acred, flags);
         put_group_info(acred.group_info);
         return ret;
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index 66d5ac4773ab..b152e2b9b988 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -467,8 +467,7 @@ static int unix_listen(struct socket *sock, int backlog)
         sk->sk_state            = TCP_LISTEN;
         /* set credentials so connect can copy them */
         sk->sk_peercred.pid     = task_tgid_vnr(current);
-        sk->sk_peercred.uid     = current->euid;
-        sk->sk_peercred.gid     = current->egid;
+        current_euid_egid(&sk->sk_peercred.uid, &sk->sk_peercred.gid);
         err = 0;
 
 out_unlock:
@@ -1126,8 +1125,7 @@ restart:
         newsk->sk_state         = TCP_ESTABLISHED;
         newsk->sk_type          = sk->sk_type;
         newsk->sk_peercred.pid  = task_tgid_vnr(current);
-        newsk->sk_peercred.uid  = current->euid;
-        newsk->sk_peercred.gid  = current->egid;
+        current_euid_egid(&newsk->sk_peercred.uid, &newsk->sk_peercred.gid);
         newu = unix_sk(newsk);
         newsk->sk_sleep         = &newu->peer_wait;
         otheru = unix_sk(other);
@@ -1187,8 +1185,9 @@ static int unix_socketpair(struct socket *socka, struct socket *sockb)
         unix_peer(ska)=skb;
         unix_peer(skb)=ska;
         ska->sk_peercred.pid = skb->sk_peercred.pid = task_tgid_vnr(current);
-        ska->sk_peercred.uid = skb->sk_peercred.uid = current->euid;
-        ska->sk_peercred.gid = skb->sk_peercred.gid = current->egid;
+        current_euid_egid(&skb->sk_peercred.uid, &skb->sk_peercred.gid);
+        ska->sk_peercred.uid = skb->sk_peercred.uid;
+        ska->sk_peercred.gid = skb->sk_peercred.gid;
 
         if (ska->sk_type != SOCK_DGRAM) {
                 ska->sk_state = TCP_ESTABLISHED;