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