ipc: clean up ipc/shm.c
[linux-2.6.git] / ipc / ipc_sysctl.c
1 /*
2  *  Copyright (C) 2007
3  *
4  *  Author: Eric Biederman <ebiederm@xmision.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.
10  */
11
12 #include <linux/module.h>
13 #include <linux/ipc.h>
14 #include <linux/nsproxy.h>
15 #include <linux/sysctl.h>
16 #include <linux/uaccess.h>
17 #include <linux/ipc_namespace.h>
18 #include <linux/msg.h>
19 #include "util.h"
20
21 static void *get_ipc(ctl_table *table)
22 {
23         char *which = table->data;
24         struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns;
25         which = (which - (char *)&init_ipc_ns) + (char *)ipc_ns;
26         return which;
27 }
28
29 /*
30  * Routine that is called when the file "auto_msgmni" has successfully been
31  * written.
32  * Two values are allowed:
33  * 0: unregister msgmni's callback routine from the ipc namespace notifier
34  *    chain. This means that msgmni won't be recomputed anymore upon memory
35  *    add/remove or ipc namespace creation/removal.
36  * 1: register back the callback routine.
37  */
38 static void ipc_auto_callback(int val)
39 {
40         if (!val)
41                 unregister_ipcns_notifier(current->nsproxy->ipc_ns);
42         else {
43                 /*
44                  * Re-enable automatic recomputing only if not already
45                  * enabled.
46                  */
47                 recompute_msgmni(current->nsproxy->ipc_ns);
48                 cond_register_ipcns_notifier(current->nsproxy->ipc_ns);
49         }
50 }
51
52 #ifdef CONFIG_PROC_FS
53 static int proc_ipc_dointvec(ctl_table *table, int write, struct file *filp,
54         void __user *buffer, size_t *lenp, loff_t *ppos)
55 {
56         struct ctl_table ipc_table;
57         memcpy(&ipc_table, table, sizeof(ipc_table));
58         ipc_table.data = get_ipc(table);
59
60         return proc_dointvec(&ipc_table, write, filp, buffer, lenp, ppos);
61 }
62
63 static int proc_ipc_callback_dointvec(ctl_table *table, int write,
64         struct file *filp, void __user *buffer, size_t *lenp, loff_t *ppos)
65 {
66         struct ctl_table ipc_table;
67         size_t lenp_bef = *lenp;
68         int rc;
69
70         memcpy(&ipc_table, table, sizeof(ipc_table));
71         ipc_table.data = get_ipc(table);
72
73         rc = proc_dointvec(&ipc_table, write, filp, buffer, lenp, ppos);
74
75         if (write && !rc && lenp_bef == *lenp)
76                 /*
77                  * Tunable has successfully been changed by hand. Disable its
78                  * automatic adjustment. This simply requires unregistering
79                  * the notifiers that trigger recalculation.
80                  */
81                 unregister_ipcns_notifier(current->nsproxy->ipc_ns);
82
83         return rc;
84 }
85
86 static int proc_ipc_doulongvec_minmax(ctl_table *table, int write,
87         struct file *filp, void __user *buffer, size_t *lenp, loff_t *ppos)
88 {
89         struct ctl_table ipc_table;
90         memcpy(&ipc_table, table, sizeof(ipc_table));
91         ipc_table.data = get_ipc(table);
92
93         return proc_doulongvec_minmax(&ipc_table, write, filp, buffer,
94                                         lenp, ppos);
95 }
96
97 static int proc_ipcauto_dointvec_minmax(ctl_table *table, int write,
98         struct file *filp, void __user *buffer, size_t *lenp, loff_t *ppos)
99 {
100         struct ctl_table ipc_table;
101         size_t lenp_bef = *lenp;
102         int oldval;
103         int rc;
104
105         memcpy(&ipc_table, table, sizeof(ipc_table));
106         ipc_table.data = get_ipc(table);
107         oldval = *((int *)(ipc_table.data));
108
109         rc = proc_dointvec_minmax(&ipc_table, write, filp, buffer, lenp, ppos);
110
111         if (write && !rc && lenp_bef == *lenp) {
112                 int newval = *((int *)(ipc_table.data));
113                 /*
114                  * The file "auto_msgmni" has correctly been set.
115                  * React by (un)registering the corresponding tunable, if the
116                  * value has changed.
117                  */
118                 if (newval != oldval)
119                         ipc_auto_callback(newval);
120         }
121
122         return rc;
123 }
124
125 #else
126 #define proc_ipc_doulongvec_minmax NULL
127 #define proc_ipc_dointvec          NULL
128 #define proc_ipc_callback_dointvec NULL
129 #define proc_ipcauto_dointvec_minmax NULL
130 #endif
131
132 #ifdef CONFIG_SYSCTL_SYSCALL
133 /* The generic sysctl ipc data routine. */
134 static int sysctl_ipc_data(ctl_table *table,
135                 void __user *oldval, size_t __user *oldlenp,
136                 void __user *newval, size_t newlen)
137 {
138         size_t len;
139         void *data;
140
141         /* Get out of I don't have a variable */
142         if (!table->data || !table->maxlen)
143                 return -ENOTDIR;
144
145         data = get_ipc(table);
146         if (!data)
147                 return -ENOTDIR;
148
149         if (oldval && oldlenp) {
150                 if (get_user(len, oldlenp))
151                         return -EFAULT;
152                 if (len) {
153                         if (len > table->maxlen)
154                                 len = table->maxlen;
155                         if (copy_to_user(oldval, data, len))
156                                 return -EFAULT;
157                         if (put_user(len, oldlenp))
158                                 return -EFAULT;
159                 }
160         }
161
162         if (newval && newlen) {
163                 if (newlen > table->maxlen)
164                         newlen = table->maxlen;
165
166                 if (copy_from_user(data, newval, newlen))
167                         return -EFAULT;
168         }
169         return 1;
170 }
171
172 static int sysctl_ipc_registered_data(ctl_table *table,
173                 void __user *oldval, size_t __user *oldlenp,
174                 void __user *newval, size_t newlen)
175 {
176         int rc;
177
178         rc = sysctl_ipc_data(table, oldval, oldlenp, newval, newlen);
179
180         if (newval && newlen && rc > 0)
181                 /*
182                  * Tunable has successfully been changed from userland
183                  */
184                 unregister_ipcns_notifier(current->nsproxy->ipc_ns);
185
186         return rc;
187 }
188 #else
189 #define sysctl_ipc_data NULL
190 #define sysctl_ipc_registered_data NULL
191 #endif
192
193 static int zero;
194 static int one = 1;
195
196 static struct ctl_table ipc_kern_table[] = {
197         {
198                 .ctl_name       = KERN_SHMMAX,
199                 .procname       = "shmmax",
200                 .data           = &init_ipc_ns.shm_ctlmax,
201                 .maxlen         = sizeof (init_ipc_ns.shm_ctlmax),
202                 .mode           = 0644,
203                 .proc_handler   = proc_ipc_doulongvec_minmax,
204                 .strategy       = sysctl_ipc_data,
205         },
206         {
207                 .ctl_name       = KERN_SHMALL,
208                 .procname       = "shmall",
209                 .data           = &init_ipc_ns.shm_ctlall,
210                 .maxlen         = sizeof (init_ipc_ns.shm_ctlall),
211                 .mode           = 0644,
212                 .proc_handler   = proc_ipc_doulongvec_minmax,
213                 .strategy       = sysctl_ipc_data,
214         },
215         {
216                 .ctl_name       = KERN_SHMMNI,
217                 .procname       = "shmmni",
218                 .data           = &init_ipc_ns.shm_ctlmni,
219                 .maxlen         = sizeof (init_ipc_ns.shm_ctlmni),
220                 .mode           = 0644,
221                 .proc_handler   = proc_ipc_dointvec,
222                 .strategy       = sysctl_ipc_data,
223         },
224         {
225                 .ctl_name       = KERN_MSGMAX,
226                 .procname       = "msgmax",
227                 .data           = &init_ipc_ns.msg_ctlmax,
228                 .maxlen         = sizeof (init_ipc_ns.msg_ctlmax),
229                 .mode           = 0644,
230                 .proc_handler   = proc_ipc_dointvec,
231                 .strategy       = sysctl_ipc_data,
232         },
233         {
234                 .ctl_name       = KERN_MSGMNI,
235                 .procname       = "msgmni",
236                 .data           = &init_ipc_ns.msg_ctlmni,
237                 .maxlen         = sizeof (init_ipc_ns.msg_ctlmni),
238                 .mode           = 0644,
239                 .proc_handler   = proc_ipc_callback_dointvec,
240                 .strategy       = sysctl_ipc_registered_data,
241         },
242         {
243                 .ctl_name       = KERN_MSGMNB,
244                 .procname       =  "msgmnb",
245                 .data           = &init_ipc_ns.msg_ctlmnb,
246                 .maxlen         = sizeof (init_ipc_ns.msg_ctlmnb),
247                 .mode           = 0644,
248                 .proc_handler   = proc_ipc_dointvec,
249                 .strategy       = sysctl_ipc_data,
250         },
251         {
252                 .ctl_name       = KERN_SEM,
253                 .procname       = "sem",
254                 .data           = &init_ipc_ns.sem_ctls,
255                 .maxlen         = 4*sizeof (int),
256                 .mode           = 0644,
257                 .proc_handler   = proc_ipc_dointvec,
258                 .strategy       = sysctl_ipc_data,
259         },
260         {
261                 .ctl_name       = CTL_UNNUMBERED,
262                 .procname       = "auto_msgmni",
263                 .data           = &init_ipc_ns.auto_msgmni,
264                 .maxlen         = sizeof(int),
265                 .mode           = 0644,
266                 .proc_handler   = proc_ipcauto_dointvec_minmax,
267                 .extra1         = &zero,
268                 .extra2         = &one,
269         },
270         {}
271 };
272
273 static struct ctl_table ipc_root_table[] = {
274         {
275                 .ctl_name       = CTL_KERN,
276                 .procname       = "kernel",
277                 .mode           = 0555,
278                 .child          = ipc_kern_table,
279         },
280         {}
281 };
282
283 static int __init ipc_sysctl_init(void)
284 {
285         register_sysctl_table(ipc_root_table);
286         return 0;
287 }
288
289 __initcall(ipc_sysctl_init);