Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  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 
 19 static void *get_ipc(ctl_table *table)
 20 {
 21         char *which = table->data;
 22         struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns;
 23         which = (which - (char *)&init_ipc_ns) + (char *)ipc_ns;
 24         return which;
 25 }
 26 
 27 #ifdef CONFIG_PROC_FS
 28 static int proc_ipc_dointvec(ctl_table *table, int write, struct file *filp,
 29         void __user *buffer, size_t *lenp, loff_t *ppos)
 30 {
 31         struct ctl_table ipc_table;
 32         memcpy(&ipc_table, table, sizeof(ipc_table));
 33         ipc_table.data = get_ipc(table);
 34 
 35         return proc_dointvec(&ipc_table, write, filp, buffer, lenp, ppos);
 36 }
 37 
 38 static int proc_ipc_doulongvec_minmax(ctl_table *table, int write,
 39         struct file *filp, void __user *buffer, size_t *lenp, loff_t *ppos)
 40 {
 41         struct ctl_table ipc_table;
 42         memcpy(&ipc_table, table, sizeof(ipc_table));
 43         ipc_table.data = get_ipc(table);
 44 
 45         return proc_doulongvec_minmax(&ipc_table, write, filp, buffer,
 46                                         lenp, ppos);
 47 }
 48 
 49 #else
 50 #define proc_ipc_doulongvec_minmax NULL
 51 #define proc_ipc_dointvec          NULL
 52 #endif
 53 
 54 #ifdef CONFIG_SYSCTL_SYSCALL
 55 /* The generic sysctl ipc data routine. */
 56 static int sysctl_ipc_data(ctl_table *table, int __user *name, int nlen,
 57                 void __user *oldval, size_t __user *oldlenp,
 58                 void __user *newval, size_t newlen)
 59 {
 60         size_t len;
 61         void *data;
 62 
 63         /* Get out of I don't have a variable */
 64         if (!table->data || !table->maxlen)
 65                 return -ENOTDIR;
 66 
 67         data = get_ipc(table);
 68         if (!data)
 69                 return -ENOTDIR;
 70 
 71         if (oldval && oldlenp) {
 72                 if (get_user(len, oldlenp))
 73                         return -EFAULT;
 74                 if (len) {
 75                         if (len > table->maxlen)
 76                                 len = table->maxlen;
 77                         if (copy_to_user(oldval, data, len))
 78                                 return -EFAULT;
 79                         if (put_user(len, oldlenp))
 80                                 return -EFAULT;
 81                 }
 82         }
 83 
 84         if (newval && newlen) {
 85                 if (newlen > table->maxlen)
 86                         newlen = table->maxlen;
 87 
 88                 if (copy_from_user(data, newval, newlen))
 89                         return -EFAULT;
 90         }
 91         return 1;
 92 }
 93 #else
 94 #define sysctl_ipc_data NULL
 95 #endif
 96 
 97 static struct ctl_table ipc_kern_table[] = {
 98         {
 99                 .ctl_name       = KERN_SHMMAX,
100                 .procname       = "shmmax",
101                 .data           = &init_ipc_ns.shm_ctlmax,
102                 .maxlen         = sizeof (init_ipc_ns.shm_ctlmax),
103                 .mode           = 0644,
104                 .proc_handler   = proc_ipc_doulongvec_minmax,
105                 .strategy       = sysctl_ipc_data,
106         },
107         {
108                 .ctl_name       = KERN_SHMALL,
109                 .procname       = "shmall",
110                 .data           = &init_ipc_ns.shm_ctlall,
111                 .maxlen         = sizeof (init_ipc_ns.shm_ctlall),
112                 .mode           = 0644,
113                 .proc_handler   = proc_ipc_doulongvec_minmax,
114                 .strategy       = sysctl_ipc_data,
115         },
116         {
117                 .ctl_name       = KERN_SHMMNI,
118                 .procname       = "shmmni",
119                 .data           = &init_ipc_ns.shm_ctlmni,
120                 .maxlen         = sizeof (init_ipc_ns.shm_ctlmni),
121                 .mode           = 0644,
122                 .proc_handler   = proc_ipc_dointvec,
123                 .strategy       = sysctl_ipc_data,
124         },
125         {
126                 .ctl_name       = KERN_MSGMAX,
127                 .procname       = "msgmax",
128                 .data           = &init_ipc_ns.msg_ctlmax,
129                 .maxlen         = sizeof (init_ipc_ns.msg_ctlmax),
130                 .mode           = 0644,
131                 .proc_handler   = proc_ipc_dointvec,
132                 .strategy       = sysctl_ipc_data,
133         },
134         {
135                 .ctl_name       = KERN_MSGMNI,
136                 .procname       = "msgmni",
137                 .data           = &init_ipc_ns.msg_ctlmni,
138                 .maxlen         = sizeof (init_ipc_ns.msg_ctlmni),
139                 .mode           = 0644,
140                 .proc_handler   = proc_ipc_dointvec,
141                 .strategy       = sysctl_ipc_data,
142         },
143         {
144                 .ctl_name       = KERN_MSGMNB,
145                 .procname       =  "msgmnb",
146                 .data           = &init_ipc_ns.msg_ctlmnb,
147                 .maxlen         = sizeof (init_ipc_ns.msg_ctlmnb),
148                 .mode           = 0644,
149                 .proc_handler   = proc_ipc_dointvec,
150                 .strategy       = sysctl_ipc_data,
151         },
152         {
153                 .ctl_name       = KERN_SEM,
154                 .procname       = "sem",
155                 .data           = &init_ipc_ns.sem_ctls,
156                 .maxlen         = 4*sizeof (int),
157                 .mode           = 0644,
158                 .proc_handler   = proc_ipc_dointvec,
159                 .strategy       = sysctl_ipc_data,
160         },
161         {}
162 };
163 
164 static struct ctl_table ipc_root_table[] = {
165         {
166                 .ctl_name       = CTL_KERN,
167                 .procname       = "kernel",
168                 .mode           = 0555,
169                 .child          = ipc_kern_table,
170         },
171         {}
172 };
173 
174 static int __init ipc_sysctl_init(void)
175 {
176         register_sysctl_table(ipc_root_table);
177         return 0;
178 }
179 
180 __initcall(ipc_sysctl_init);
181 
  This page was automatically generated by the LXR engine.