x86: optimise x86's do_page_fault (C entry point for the page fault path)
[linux-2.6.git] / arch / ia64 / sn / kernel / sn2 / sn_proc_fs.c
index 51bf827..2526e5c 100644 (file)
@@ -5,12 +5,11 @@
  *
  * Copyright (C) 2000-2005 Silicon Graphics, Inc. All rights reserved.
  */
-#include <linux/config.h>
-#include <asm/uaccess.h>
 
 #ifdef CONFIG_PROC_FS
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <asm/uaccess.h>
 #include <asm/sn/sn_sal.h>
 
 static int partition_id_show(struct seq_file *s, void *p)
@@ -52,7 +51,7 @@ static int licenseID_open(struct inode *inode, struct file *file)
  * the bridge chip.  The hardware will then send an interrupt message if the
  * interrupt line is active.  This mimics a level sensitive interrupt.
  */
-int sn_force_interrupt_flag = 1;
+extern int sn_force_interrupt_flag;
 
 static int sn_force_interrupt_show(struct seq_file *s, void *p)
 {
@@ -90,60 +89,71 @@ static int coherence_id_open(struct inode *inode, struct file *file)
        return single_open(file, coherence_id_show, NULL);
 }
 
-static struct proc_dir_entry *sn_procfs_create_entry(
-       const char *name, struct proc_dir_entry *parent,
-       int (*openfunc)(struct inode *, struct file *),
-       int (*releasefunc)(struct inode *, struct file *))
-{
-       struct proc_dir_entry *e = create_proc_entry(name, 0444, parent);
-
-       if (e) {
-               e->proc_fops = (struct file_operations *)kmalloc(
-                       sizeof(struct file_operations), GFP_KERNEL);
-               if (e->proc_fops) {
-                       memset(e->proc_fops, 0, sizeof(struct file_operations));
-                       e->proc_fops->open = openfunc;
-                       e->proc_fops->read = seq_read;
-                       e->proc_fops->llseek = seq_lseek;
-                       e->proc_fops->release = releasefunc;
-               }
-       }
-
-       return e;
-}
-
 /* /proc/sgi_sn/sn_topology uses seq_file, see sn_hwperf.c */
 extern int sn_topology_open(struct inode *, struct file *);
 extern int sn_topology_release(struct inode *, struct file *);
 
+static const struct file_operations proc_partition_id_fops = {
+       .open           = partition_id_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = single_release,
+};
+
+static const struct file_operations proc_system_sn_fops = {
+       .open           = system_serial_number_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = single_release,
+};
+
+static const struct file_operations proc_license_id_fops = {
+       .open           = licenseID_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = single_release,
+};
+
+static const struct file_operations proc_sn_force_intr_fops = {
+       .open           = sn_force_interrupt_open,
+       .read           = seq_read,
+       .write          = sn_force_interrupt_write_proc,
+       .llseek         = seq_lseek,
+       .release        = single_release,
+};
+
+static const struct file_operations proc_coherence_id_fops = {
+       .open           = coherence_id_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = single_release,
+};
+
+static const struct file_operations proc_sn_topo_fops = {
+       .open           = sn_topology_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = sn_topology_release,
+};
+
 void register_sn_procfs(void)
 {
        static struct proc_dir_entry *sgi_proc_dir = NULL;
-       struct proc_dir_entry *e;
 
        BUG_ON(sgi_proc_dir != NULL);
        if (!(sgi_proc_dir = proc_mkdir("sgi_sn", NULL)))
                return;
 
-       sn_procfs_create_entry("partition_id", sgi_proc_dir,
-               partition_id_open, single_release);
-
-       sn_procfs_create_entry("system_serial_number", sgi_proc_dir,
-               system_serial_number_open, single_release);
-
-       sn_procfs_create_entry("licenseID", sgi_proc_dir, 
-               licenseID_open, single_release);
-
-       e = sn_procfs_create_entry("sn_force_interrupt", sgi_proc_dir, 
-               sn_force_interrupt_open, single_release);
-       if (e) 
-               e->proc_fops->write = sn_force_interrupt_write_proc;
-
-       sn_procfs_create_entry("coherence_id", sgi_proc_dir, 
-               coherence_id_open, single_release);
-       
-       sn_procfs_create_entry("sn_topology", sgi_proc_dir,
-               sn_topology_open, sn_topology_release);
+       proc_create("partition_id", 0444, sgi_proc_dir,
+                   &proc_partition_id_fops);
+       proc_create("system_serial_number", 0444, sgi_proc_dir,
+                   &proc_system_sn_fops);
+       proc_create("licenseID", 0444, sgi_proc_dir, &proc_license_id_fops);
+       proc_create("sn_force_interrupt", 0644, sgi_proc_dir,
+                   &proc_sn_force_intr_fops);
+       proc_create("coherence_id", 0444, sgi_proc_dir,
+                   &proc_coherence_id_fops);
+       proc_create("sn_topology", 0444, sgi_proc_dir, &proc_sn_topo_fops);
 }
 
 #endif /* CONFIG_PROC_FS */