1 // SPDX-License-Identifier: GPL-2.0-only 1 // SPDX-License-Identifier: GPL-2.0-only
2 /* 2 /*
3 * Copyright (C) 2004 IBM Corporation 3 * Copyright (C) 2004 IBM Corporation
4 * 4 *
5 * Author: Serge Hallyn <serue@us.ibm.com> 5 * Author: Serge Hallyn <serue@us.ibm.com>
6 */ 6 */
7 7
8 #include <linux/export.h> 8 #include <linux/export.h>
9 #include <linux/uts.h> 9 #include <linux/uts.h>
10 #include <linux/utsname.h> 10 #include <linux/utsname.h>
11 #include <linux/err.h> 11 #include <linux/err.h>
12 #include <linux/slab.h> 12 #include <linux/slab.h>
13 #include <linux/cred.h> 13 #include <linux/cred.h>
14 #include <linux/user_namespace.h> 14 #include <linux/user_namespace.h>
15 #include <linux/proc_ns.h> 15 #include <linux/proc_ns.h>
16 #include <linux/sched/task.h> 16 #include <linux/sched/task.h>
17 17
18 static struct kmem_cache *uts_ns_cache __ro_af 18 static struct kmem_cache *uts_ns_cache __ro_after_init;
19 19
20 static struct ucounts *inc_uts_namespaces(stru 20 static struct ucounts *inc_uts_namespaces(struct user_namespace *ns)
21 { 21 {
22 return inc_ucount(ns, current_euid(), 22 return inc_ucount(ns, current_euid(), UCOUNT_UTS_NAMESPACES);
23 } 23 }
24 24
25 static void dec_uts_namespaces(struct ucounts 25 static void dec_uts_namespaces(struct ucounts *ucounts)
26 { 26 {
27 dec_ucount(ucounts, UCOUNT_UTS_NAMESPA 27 dec_ucount(ucounts, UCOUNT_UTS_NAMESPACES);
28 } 28 }
29 29
30 static struct uts_namespace *create_uts_ns(voi 30 static struct uts_namespace *create_uts_ns(void)
31 { 31 {
32 struct uts_namespace *uts_ns; 32 struct uts_namespace *uts_ns;
33 33
34 uts_ns = kmem_cache_alloc(uts_ns_cache 34 uts_ns = kmem_cache_alloc(uts_ns_cache, GFP_KERNEL);
35 if (uts_ns) 35 if (uts_ns)
36 refcount_set(&uts_ns->ns.count !! 36 kref_init(&uts_ns->kref);
37 return uts_ns; 37 return uts_ns;
38 } 38 }
39 39
40 /* 40 /*
41 * Clone a new ns copying an original utsname, 41 * Clone a new ns copying an original utsname, setting refcount to 1
42 * @old_ns: namespace to clone 42 * @old_ns: namespace to clone
43 * Return ERR_PTR(-ENOMEM) on error (failure t 43 * Return ERR_PTR(-ENOMEM) on error (failure to allocate), new ns otherwise
44 */ 44 */
45 static struct uts_namespace *clone_uts_ns(stru 45 static struct uts_namespace *clone_uts_ns(struct user_namespace *user_ns,
46 stru 46 struct uts_namespace *old_ns)
47 { 47 {
48 struct uts_namespace *ns; 48 struct uts_namespace *ns;
49 struct ucounts *ucounts; 49 struct ucounts *ucounts;
50 int err; 50 int err;
51 51
52 err = -ENOSPC; 52 err = -ENOSPC;
53 ucounts = inc_uts_namespaces(user_ns); 53 ucounts = inc_uts_namespaces(user_ns);
54 if (!ucounts) 54 if (!ucounts)
55 goto fail; 55 goto fail;
56 56
57 err = -ENOMEM; 57 err = -ENOMEM;
58 ns = create_uts_ns(); 58 ns = create_uts_ns();
59 if (!ns) 59 if (!ns)
60 goto fail_dec; 60 goto fail_dec;
61 61
62 err = ns_alloc_inum(&ns->ns); 62 err = ns_alloc_inum(&ns->ns);
63 if (err) 63 if (err)
64 goto fail_free; 64 goto fail_free;
65 65
66 ns->ucounts = ucounts; 66 ns->ucounts = ucounts;
67 ns->ns.ops = &utsns_operations; 67 ns->ns.ops = &utsns_operations;
68 68
69 down_read(&uts_sem); 69 down_read(&uts_sem);
70 memcpy(&ns->name, &old_ns->name, sizeo 70 memcpy(&ns->name, &old_ns->name, sizeof(ns->name));
71 ns->user_ns = get_user_ns(user_ns); 71 ns->user_ns = get_user_ns(user_ns);
72 up_read(&uts_sem); 72 up_read(&uts_sem);
73 return ns; 73 return ns;
74 74
75 fail_free: 75 fail_free:
76 kmem_cache_free(uts_ns_cache, ns); 76 kmem_cache_free(uts_ns_cache, ns);
77 fail_dec: 77 fail_dec:
78 dec_uts_namespaces(ucounts); 78 dec_uts_namespaces(ucounts);
79 fail: 79 fail:
80 return ERR_PTR(err); 80 return ERR_PTR(err);
81 } 81 }
82 82
83 /* 83 /*
84 * Copy task tsk's utsname namespace, or clone 84 * Copy task tsk's utsname namespace, or clone it if flags
85 * specifies CLONE_NEWUTS. In latter case, ch 85 * specifies CLONE_NEWUTS. In latter case, changes to the
86 * utsname of this process won't be seen by pa 86 * utsname of this process won't be seen by parent, and vice
87 * versa. 87 * versa.
88 */ 88 */
89 struct uts_namespace *copy_utsname(unsigned lo 89 struct uts_namespace *copy_utsname(unsigned long flags,
90 struct user_namespace *user_ns, struct 90 struct user_namespace *user_ns, struct uts_namespace *old_ns)
91 { 91 {
92 struct uts_namespace *new_ns; 92 struct uts_namespace *new_ns;
93 93
94 BUG_ON(!old_ns); 94 BUG_ON(!old_ns);
95 get_uts_ns(old_ns); 95 get_uts_ns(old_ns);
96 96
97 if (!(flags & CLONE_NEWUTS)) 97 if (!(flags & CLONE_NEWUTS))
98 return old_ns; 98 return old_ns;
99 99
100 new_ns = clone_uts_ns(user_ns, old_ns) 100 new_ns = clone_uts_ns(user_ns, old_ns);
101 101
102 put_uts_ns(old_ns); 102 put_uts_ns(old_ns);
103 return new_ns; 103 return new_ns;
104 } 104 }
105 105
106 void free_uts_ns(struct uts_namespace *ns) !! 106 void free_uts_ns(struct kref *kref)
107 { 107 {
>> 108 struct uts_namespace *ns;
>> 109
>> 110 ns = container_of(kref, struct uts_namespace, kref);
108 dec_uts_namespaces(ns->ucounts); 111 dec_uts_namespaces(ns->ucounts);
109 put_user_ns(ns->user_ns); 112 put_user_ns(ns->user_ns);
110 ns_free_inum(&ns->ns); 113 ns_free_inum(&ns->ns);
111 kmem_cache_free(uts_ns_cache, ns); 114 kmem_cache_free(uts_ns_cache, ns);
112 } 115 }
113 116
114 static inline struct uts_namespace *to_uts_ns( 117 static inline struct uts_namespace *to_uts_ns(struct ns_common *ns)
115 { 118 {
116 return container_of(ns, struct uts_nam 119 return container_of(ns, struct uts_namespace, ns);
117 } 120 }
118 121
119 static struct ns_common *utsns_get(struct task 122 static struct ns_common *utsns_get(struct task_struct *task)
120 { 123 {
121 struct uts_namespace *ns = NULL; 124 struct uts_namespace *ns = NULL;
122 struct nsproxy *nsproxy; 125 struct nsproxy *nsproxy;
123 126
124 task_lock(task); 127 task_lock(task);
125 nsproxy = task->nsproxy; 128 nsproxy = task->nsproxy;
126 if (nsproxy) { 129 if (nsproxy) {
127 ns = nsproxy->uts_ns; 130 ns = nsproxy->uts_ns;
128 get_uts_ns(ns); 131 get_uts_ns(ns);
129 } 132 }
130 task_unlock(task); 133 task_unlock(task);
131 134
132 return ns ? &ns->ns : NULL; 135 return ns ? &ns->ns : NULL;
133 } 136 }
134 137
135 static void utsns_put(struct ns_common *ns) 138 static void utsns_put(struct ns_common *ns)
136 { 139 {
137 put_uts_ns(to_uts_ns(ns)); 140 put_uts_ns(to_uts_ns(ns));
138 } 141 }
139 142
140 static int utsns_install(struct nsset *nsset, !! 143 static int utsns_install(struct nsproxy *nsproxy, struct ns_common *new)
141 { 144 {
142 struct nsproxy *nsproxy = nsset->nspro <<
143 struct uts_namespace *ns = to_uts_ns(n 145 struct uts_namespace *ns = to_uts_ns(new);
144 146
145 if (!ns_capable(ns->user_ns, CAP_SYS_A 147 if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN) ||
146 !ns_capable(nsset->cred->user_ns, !! 148 !ns_capable(current_user_ns(), CAP_SYS_ADMIN))
147 return -EPERM; 149 return -EPERM;
148 150
149 get_uts_ns(ns); 151 get_uts_ns(ns);
150 put_uts_ns(nsproxy->uts_ns); 152 put_uts_ns(nsproxy->uts_ns);
151 nsproxy->uts_ns = ns; 153 nsproxy->uts_ns = ns;
152 return 0; 154 return 0;
153 } 155 }
154 156
155 static struct user_namespace *utsns_owner(stru 157 static struct user_namespace *utsns_owner(struct ns_common *ns)
156 { 158 {
157 return to_uts_ns(ns)->user_ns; 159 return to_uts_ns(ns)->user_ns;
158 } 160 }
159 161
160 const struct proc_ns_operations utsns_operatio 162 const struct proc_ns_operations utsns_operations = {
161 .name = "uts", 163 .name = "uts",
162 .type = CLONE_NEWUTS, 164 .type = CLONE_NEWUTS,
163 .get = utsns_get, 165 .get = utsns_get,
164 .put = utsns_put, 166 .put = utsns_put,
165 .install = utsns_install, 167 .install = utsns_install,
166 .owner = utsns_owner, 168 .owner = utsns_owner,
167 }; 169 };
168 170
169 void __init uts_ns_init(void) 171 void __init uts_ns_init(void)
170 { 172 {
171 uts_ns_cache = kmem_cache_create_userc 173 uts_ns_cache = kmem_cache_create_usercopy(
172 "uts_namespace", sizeo 174 "uts_namespace", sizeof(struct uts_namespace), 0,
173 SLAB_PANIC|SLAB_ACCOUN 175 SLAB_PANIC|SLAB_ACCOUNT,
174 offsetof(struct uts_na 176 offsetof(struct uts_namespace, name),
175 sizeof_field(struct ut 177 sizeof_field(struct uts_namespace, name),
176 NULL); 178 NULL);
177 } 179 }
178 180
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.