sparc: Fix use of uid16_t and gid16_t in asm/stat.h
[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 #ifdef CONFIG_PROC_SYSCTL
30 static int proc_ipc_dointvec(ctl_table *table, int write,
31         void __user *buffer, size_t *lenp, loff_t *ppos)
32 {
33         struct ctl_table ipc_table;
34         memcpy(&ipc_table, table, sizeof(ipc_table));
35         ipc_table.data = get_ipc(table);
36
37         return proc_dointvec(&ipc_table, write, buffer, lenp, ppos);
38 }
39
40 static int proc_ipc_callback_dointvec(ctl_table *table, int write,
41         void __user *buffer, size_t *lenp, loff_t *ppos)
42 {
43         struct ctl_table ipc_table;
44         size_t lenp_bef = *lenp;
45         int rc;
46
47         memcpy(&ipc_table, table, sizeof(ipc_table));
48         ipc_table.data = get_ipc(table);
49
50         rc = proc_dointvec(&ipc_table, write, buffer, lenp, ppos);
51
52         if (write && !rc && lenp_bef == *lenp)
53                 /*
54                  * Tunable has successfully been changed by hand. Disable its
55                  * automatic adjustment. This simply requires unregistering
56                  * the notifiers that trigger recalculation.
57                  */
58                 unregister_ipcns_notifier(current->nsproxy->ipc_ns);
59
60         return rc;
61 }
62
63 static int proc_ipc_doulongvec_minmax(ctl_table *table, int write,
64         void __user *buffer, size_t *lenp, loff_t *ppos)
65 {
66         struct ctl_table ipc_table;
67         memcpy(&ipc_table, table, sizeof(ipc_table));
68         ipc_table.data = get_ipc(table);
69
70         return proc_doulongvec_minmax(&ipc_table, write, buffer,
71                                         lenp, ppos);
72 }
73
74 /*
75  * Routine that is called when the file "auto_msgmni" has successfully been
76  * written.
77  * Two values are allowed:
78  * 0: unregister msgmni's callback routine from the ipc namespace notifier
79  *    chain. This means that msgmni won't be recomputed anymore upon memory
80  *    add/remove or ipc namespace creation/removal.
81  * 1: register back the callback routine.
82  */
83 static void ipc_auto_callback(int val)
84 {
85         if (!val)
86                 unregister_ipcns_notifier(current->nsproxy->ipc_ns);
87         else {
88                 /*
89                  * Re-enable automatic recomputing only if not already
90                  * enabled.
91                  */
92                 recompute_msgmni(current->nsproxy->ipc_ns);
93                 cond_register_ipcns_notifier(current->nsproxy->ipc_ns);
94         }
95 }
96
97 static int proc_ipcauto_dointvec_minmax(ctl_table *table, int write,
98         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, 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 static int zero;
133 static int one = 1;
134
135 static struct ctl_table ipc_kern_table[] = {
136         {
137                 .procname       = "shmmax",
138                 .data           = &init_ipc_ns.shm_ctlmax,
139                 .maxlen         = sizeof (init_ipc_ns.shm_ctlmax),
140                 .mode           = 0644,
141                 .proc_handler   = proc_ipc_doulongvec_minmax,
142         },
143         {
144                 .procname       = "shmall",
145                 .data           = &init_ipc_ns.shm_ctlall,
146                 .maxlen         = sizeof (init_ipc_ns.shm_ctlall),
147                 .mode           = 0644,
148                 .proc_handler   = proc_ipc_doulongvec_minmax,
149         },
150         {
151                 .procname       = "shmmni",
152                 .data           = &init_ipc_ns.shm_ctlmni,
153                 .maxlen         = sizeof (init_ipc_ns.shm_ctlmni),
154                 .mode           = 0644,
155                 .proc_handler   = proc_ipc_dointvec,
156         },
157         {
158                 .procname       = "msgmax",
159                 .data           = &init_ipc_ns.msg_ctlmax,
160                 .maxlen         = sizeof (init_ipc_ns.msg_ctlmax),
161                 .mode           = 0644,
162                 .proc_handler   = proc_ipc_dointvec,
163         },
164         {
165                 .procname       = "msgmni",
166                 .data           = &init_ipc_ns.msg_ctlmni,
167                 .maxlen         = sizeof (init_ipc_ns.msg_ctlmni),
168                 .mode           = 0644,
169                 .proc_handler   = proc_ipc_callback_dointvec,
170         },
171         {
172                 .procname       =  "msgmnb",
173                 .data           = &init_ipc_ns.msg_ctlmnb,
174                 .maxlen         = sizeof (init_ipc_ns.msg_ctlmnb),
175                 .mode           = 0644,
176                 .proc_handler   = proc_ipc_dointvec,
177         },
178         {
179                 .procname       = "sem",
180                 .data           = &init_ipc_ns.sem_ctls,
181                 .maxlen         = 4*sizeof (int),
182                 .mode           = 0644,
183                 .proc_handler   = proc_ipc_dointvec,
184         },
185         {
186                 .procname       = "auto_msgmni",
187                 .data           = &init_ipc_ns.auto_msgmni,
188                 .maxlen         = sizeof(int),
189                 .mode           = 0644,
190                 .proc_handler   = proc_ipcauto_dointvec_minmax,
191                 .extra1         = &zero,
192                 .extra2         = &one,
193         },
194         {}
195 };
196
197 static struct ctl_table ipc_root_table[] = {
198         {
199                 .procname       = "kernel",
200                 .mode           = 0555,
201                 .child          = ipc_kern_table,
202         },
203         {}
204 };
205
206 static int __init ipc_sysctl_init(void)
207 {
208         register_sysctl_table(ipc_root_table);
209         return 0;
210 }
211
212 __initcall(ipc_sysctl_init);