arch/alpha/kernel/srm_env.c

   1 /*
   2  * srm_env.c - Access to SRM environment
   3  *             variables through linux' procfs
   4  *
   5  * (C) 2001,2002,2006 by Jan-Benedict Glaw <jbglaw@lug-owl.de>
   6  *
   7  * This driver is at all a modified version of Erik Mouw's
   8  * Documentation/DocBook/procfs_example.c, so: thank
   9  * you, Erik! He can be reached via email at
  10  * <J.A.K.Mouw@its.tudelft.nl>. It is based on an idea
  11  * provided by DEC^WCompaq^WIntel's "Jumpstart" CD. They
  12  * included a patch like this as well. Thanks for idea!
  13  *
  14  * This program is free software; you can redistribute
  15  * it and/or modify it under the terms of the GNU General
  16  * Public License version 2 as published by the Free Software
  17  * Foundation.
  18  *
  19  * This program is distributed in the hope that it will be
  20  * useful, but WITHOUT ANY WARRANTY; without even the implied
  21  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  22  * PURPOSE.  See the GNU General Public License for more
  23  * details.
  24  *
  25  * You should have received a copy of the GNU General Public
  26  * License along with this program; if not, write to the
  27  * Free Software Foundation, Inc., 59 Temple Place,
  28  * Suite 330, Boston, MA  02111-1307  USA
  29  *
  30  */
  31
  32 #include <linux/kernel.h>
  33 #include <linux/module.h>
  34 #include <linux/init.h>
  35 #include <linux/proc_fs.h>
  36 #include <asm/console.h>
  37 #include <asm/uaccess.h>
  38 #include <asm/machvec.h>
  39
  40 #define BASE_DIR        "srm_environment"       /* Subdir in /proc/             */
  41 #define NAMED_DIR       "named_variables"       /* Subdir for known variables   */
  42 #define NUMBERED_DIR    "numbered_variables"    /* Subdir for all variables     */
  43 #define VERSION         "0.0.6"                 /* Module version               */
  44 #define NAME            "srm_env"               /* Module name                  */
  45
  46 MODULE_AUTHOR("Jan-Benedict Glaw <jbglaw@lug-owl.de>");
  47 MODULE_DESCRIPTION("Accessing Alpha SRM environment through procfs interface");
  48 MODULE_LICENSE("GPL");
  49
  50 typedef struct _srm_env {
  51         char                    *name;
  52         unsigned long           id;
  53         struct proc_dir_entry   *proc_entry;
  54 } srm_env_t;
  55
  56 static struct proc_dir_entry    *base_dir;
  57 static struct proc_dir_entry    *named_dir;
  58 static struct proc_dir_entry    *numbered_dir;
  59 static char                     number[256][4];
  60
  61 static srm_env_t        srm_named_entries[] = {
  62         { "auto_action",        ENV_AUTO_ACTION         },
  63         { "boot_dev",           ENV_BOOT_DEV            },
  64         { "bootdef_dev",        ENV_BOOTDEF_DEV         },
  65         { "booted_dev",         ENV_BOOTED_DEV          },
  66         { "boot_file",          ENV_BOOT_FILE           },
  67         { "booted_file",        ENV_BOOTED_FILE         },
  68         { "boot_osflags",       ENV_BOOT_OSFLAGS        },
  69         { "booted_osflags",     ENV_BOOTED_OSFLAGS      },
  70         { "boot_reset",         ENV_BOOT_RESET          },
  71         { "dump_dev",           ENV_DUMP_DEV            },
  72         { "enable_audit",       ENV_ENABLE_AUDIT        },
  73         { "license",            ENV_LICENSE             },
  74         { "char_set",           ENV_CHAR_SET            },
  75         { "language",           ENV_LANGUAGE            },
  76         { "tty_dev",            ENV_TTY_DEV             },
  77         { NULL,                 0                       },
  78 };
  79 static srm_env_t        srm_numbered_entries[256];
  80
  81
  82 static int
  83 srm_env_read(char *page, char **start, off_t off, int count, int *eof,
  84                 void *data)
  85 {
  86         int             nbytes;
  87         unsigned long   ret;
  88         srm_env_t       *entry;
  89
  90         if (off != 0) {
  91                 *eof = 1;
  92                 return 0;
  93         }
  94
  95         entry   = (srm_env_t *) data;
  96         ret     = callback_getenv(entry->id, page, count);
  97
  98         if ((ret >> 61) == 0) {
  99                 nbytes = (int) ret;
 100                 *eof = 1;
 101         } else
 102                 nbytes = -EFAULT;
 103
 104         return nbytes;
 105 }
 106
 107 static int
 108 srm_env_write(struct file *file, const char __user *buffer, unsigned long count,
 109                 void *data)
 110 {
 111         int res;
 112         srm_env_t       *entry;
 113         char            *buf = (char *) __get_free_page(GFP_USER);
 114         unsigned long   ret1, ret2;
 115
 116         entry = (srm_env_t *) data;
 117
 118         if (!buf)
 119                 return -ENOMEM;
 120
 121         res = -EINVAL;
 122         if (count >= PAGE_SIZE)
 123                 goto out;
 124
 125         res = -EFAULT;
 126         if (copy_from_user(buf, buffer, count))
 127                 goto out;
 128         buf[count] = '\0';
 129
 130         ret1 = callback_setenv(entry->id, buf, count);
 131         if ((ret1 >> 61) == 0) {
 132                 do
 133                         ret2 = callback_save_env();
 134                 while((ret2 >> 61) == 1);
 135                 res = (int) ret1;
 136         }
 137
 138  out:
 139         free_page((unsigned long)buf);
 140         return res;
 141 }
 142
 143 static void
 144 srm_env_cleanup(void)
 145 {
 146         srm_env_t       *entry;
 147         unsigned long   var_num;
 148
 149         if (base_dir) {
 150                 /*
 151                  * Remove named entries
 152                  */
 153                 if (named_dir) {
 154                         entry = srm_named_entries;
 155                         while (entry->name != NULL && entry->id != 0) {
 156                                 if (entry->proc_entry) {
 157                                         remove_proc_entry(entry->name,
 158                                                         named_dir);
 159                                         entry->proc_entry = NULL;
 160                                 }
 161                                 entry++;
 162                         }
 163                         remove_proc_entry(NAMED_DIR, base_dir);
 164                 }
 165
 166                 /*
 167                  * Remove numbered entries
 168                  */
 169                 if (numbered_dir) {
 170                         for (var_num = 0; var_num <= 255; var_num++) {
 171                                 entry = &srm_numbered_entries[var_num];
 172
 173                                 if (entry->proc_entry) {
 174                                         remove_proc_entry(entry->name,
 175                                                         numbered_dir);
 176                                         entry->proc_entry       = NULL;
 177                                         entry->name             = NULL;
 178                                 }
 179                         }
 180                         remove_proc_entry(NUMBERED_DIR, base_dir);
 181                 }
 182
 183                 remove_proc_entry(BASE_DIR, NULL);
 184         }
 185
 186         return;
 187 }
 188
 189 static int __init
 190 srm_env_init(void)
 191 {
 192         srm_env_t       *entry;
 193         unsigned long   var_num;
 194
 195         /*
 196          * Check system
 197          */
 198         if (!alpha_using_srm) {
 199                 printk(KERN_INFO "%s: This Alpha system doesn't "
 200                                 "know about SRM (or you've booted "
 201                                 "SRM->MILO->Linux, which gets "
 202                                 "misdetected)...\n", __func__);
 203                 return -ENODEV;
 204         }
 205
 206         /*
 207          * Init numbers
 208          */
 209         for (var_num = 0; var_num <= 255; var_num++)
 210                 sprintf(number[var_num], "%ld", var_num);
 211
 212         /*
 213          * Create base directory
 214          */
 215         base_dir = proc_mkdir(BASE_DIR, NULL);
 216         if (!base_dir) {
 217                 printk(KERN_ERR "Couldn't create base dir /proc/%s\n",
 218                                 BASE_DIR);
 219                 goto cleanup;
 220         }
 221
 222         /*
 223          * Create per-name subdirectory
 224          */
 225         named_dir = proc_mkdir(NAMED_DIR, base_dir);
 226         if (!named_dir) {
 227                 printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
 228                                 BASE_DIR, NAMED_DIR);
 229                 goto cleanup;
 230         }
 231
 232         /*
 233          * Create per-number subdirectory
 234          */
 235         numbered_dir = proc_mkdir(NUMBERED_DIR, base_dir);
 236         if (!numbered_dir) {
 237                 printk(KERN_ERR "Couldn't create dir /proc/%s/%s\n",
 238                                 BASE_DIR, NUMBERED_DIR);
 239                 goto cleanup;
 240
 241         }
 242
 243         /*
 244          * Create all named nodes
 245          */
 246         entry = srm_named_entries;
 247         while (entry->name && entry->id) {
 248                 entry->proc_entry = create_proc_entry(entry->name,
 249                                 0644, named_dir);
 250                 if (!entry->proc_entry)
 251                         goto cleanup;
 252
 253                 entry->proc_entry->data         = (void *) entry;
 254                 entry->proc_entry->read_proc    = srm_env_read;
 255                 entry->proc_entry->write_proc   = srm_env_write;
 256
 257                 entry++;
 258         }
 259
 260         /*
 261          * Create all numbered nodes
 262          */
 263         for (var_num = 0; var_num <= 255; var_num++) {
 264                 entry = &srm_numbered_entries[var_num];
 265                 entry->name = number[var_num];
 266
 267                 entry->proc_entry = create_proc_entry(entry->name,
 268                                 0644, numbered_dir);
 269                 if (!entry->proc_entry)
 270                         goto cleanup;
 271
 272                 entry->id                       = var_num;
 273                 entry->proc_entry->data         = (void *) entry;
 274                 entry->proc_entry->read_proc    = srm_env_read;
 275                 entry->proc_entry->write_proc   = srm_env_write;
 276         }
 277
 278         printk(KERN_INFO "%s: version %s loaded successfully\n", NAME,
 279                         VERSION);
 280
 281         return 0;
 282
 283 cleanup:
 284         srm_env_cleanup();
 285
 286         return -ENOMEM;
 287 }
 288
 289 static void __exit
 290 srm_env_exit(void)
 291 {
 292         srm_env_cleanup();
 293         printk(KERN_INFO "%s: unloaded successfully\n", NAME);
 294
 295         return;
 296 }
 297
 298 module_init(srm_env_init);
 299 module_exit(srm_env_exit);