Line data    Source code

       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/export.h>
      13             : #include <linux/uts.h>
      14             : #include <linux/utsname.h>
      15             : #include <linux/sysctl.h>
      16             : #include <linux/wait.h>
      17             : 
      18             : #ifdef CONFIG_PROC_SYSCTL
      19             : 
      20           0 : static void *get_uts(struct ctl_table *table, int write)
      21             : {
      22           0 :         char *which = table->data;
      23             :         struct uts_namespace *uts_ns;
      24             : 
      25           0 :         uts_ns = current->nsproxy->uts_ns;
      26           0 :         which = (which - (char *)&init_uts_ns) + (char *)uts_ns;
      27             : 
      28           0 :         if (!write)
      29           0 :                 down_read(&uts_sem);
      30             :         else
      31           0 :                 down_write(&uts_sem);
      32           0 :         return which;
      33             : }
      34             : 
      35           0 : static void put_uts(struct ctl_table *table, int write, void *which)
      36             : {
      37           0 :         if (!write)
      38           0 :                 up_read(&uts_sem);
      39             :         else
      40           0 :                 up_write(&uts_sem);
      41           0 : }
      42             : 
      43             : /*
      44             :  *      Special case of dostring for the UTS structure. This has locks
      45             :  *      to observe. Should this be in kernel/sys.c ????
      46             :  */
      47           0 : static int proc_do_uts_string(struct ctl_table *table, int write,
      48             :                   void __user *buffer, size_t *lenp, loff_t *ppos)
      49             : {
      50             :         struct ctl_table uts_table;
      51             :         int r;
      52           0 :         memcpy(&uts_table, table, sizeof(uts_table));
      53           0 :         uts_table.data = get_uts(table, write);
      54           0 :         r = proc_dostring(&uts_table, write, buffer, lenp, ppos);
      55           0 :         put_uts(table, write, uts_table.data);
      56             : 
      57           0 :         if (write)
      58           0 :                 proc_sys_poll_notify(table->poll);
      59             : 
      60           0 :         return r;
      61             : }
      62             : #else
      63             : #define proc_do_uts_string NULL
      64             : #endif
      65             : 
      66             : static DEFINE_CTL_TABLE_POLL(hostname_poll);
      67             : static DEFINE_CTL_TABLE_POLL(domainname_poll);
      68             : 
      69             : static struct ctl_table uts_kern_table[] = {
      70             :         {
      71             :                 .procname       = "ostype",
      72             :                 .data           = init_uts_ns.name.sysname,
      73             :                 .maxlen         = sizeof(init_uts_ns.name.sysname),
      74             :                 .mode           = 0444,
      75             :                 .proc_handler   = proc_do_uts_string,
      76             :         },
      77             :         {
      78             :                 .procname       = "osrelease",
      79             :                 .data           = init_uts_ns.name.release,
      80             :                 .maxlen         = sizeof(init_uts_ns.name.release),
      81             :                 .mode           = 0444,
      82             :                 .proc_handler   = proc_do_uts_string,
      83             :         },
      84             :         {
      85             :                 .procname       = "version",
      86             :                 .data           = init_uts_ns.name.version,
      87             :                 .maxlen         = sizeof(init_uts_ns.name.version),
      88             :                 .mode           = 0444,
      89             :                 .proc_handler   = proc_do_uts_string,
      90             :         },
      91             :         {
      92             :                 .procname       = "hostname",
      93             :                 .data           = init_uts_ns.name.nodename,
      94             :                 .maxlen         = sizeof(init_uts_ns.name.nodename),
      95             :                 .mode           = 0644,
      96             :                 .proc_handler   = proc_do_uts_string,
      97             :                 .poll           = &hostname_poll,
      98             :         },
      99             :         {
     100             :                 .procname       = "domainname",
     101             :                 .data           = init_uts_ns.name.domainname,
     102             :                 .maxlen         = sizeof(init_uts_ns.name.domainname),
     103             :                 .mode           = 0644,
     104             :                 .proc_handler   = proc_do_uts_string,
     105             :                 .poll           = &domainname_poll,
     106             :         },
     107             :         {}
     108             : };
     109             : 
     110             : static struct ctl_table uts_root_table[] = {
     111             :         {
     112             :                 .procname       = "kernel",
     113             :                 .mode           = 0555,
     114             :                 .child          = uts_kern_table,
     115             :         },
     116             :         {}
     117             : };
     118             : 
     119             : #ifdef CONFIG_PROC_SYSCTL
     120             : /*
     121             :  * Notify userspace about a change in a certain entry of uts_kern_table,
     122             :  * identified by the parameter proc.
     123             :  */
     124           1 : void uts_proc_notify(enum uts_proc proc)
     125             : {
     126           1 :         struct ctl_table *table = &uts_kern_table[proc];
     127             : 
     128           1 :         proc_sys_poll_notify(table->poll);
     129           1 : }
     130             : #endif
     131             : 
     132           1 : static int __init utsname_sysctl_init(void)
     133             : {
     134           1 :         register_sysctl_table(uts_root_table);
     135           1 :         return 0;
     136             : }
     137             : 
     138             : device_initcall(utsname_sysctl_init);