static int
 spufs_new_file(struct super_block *sb, struct dentry *dentry,
-               struct file_operations *fops, int mode,
+               const struct file_operations *fops, int mode,
                struct spu_context *ctx)
 {
        static struct inode_operations spufs_file_iops = {
 
        return single_open(file, ppc_htab_show, NULL);
 }
 
-struct file_operations ppc_htab_operations = {
+const struct file_operations ppc_htab_operations = {
        .open           = ppc_htab_open,
        .read           = seq_read,
        .llseek         = seq_lseek,
 
        drm_device_t *dev = NULL;
        int minor = iminor(inode);
        int err = -ENODEV;
-       struct file_operations *old_fops;
+       const struct file_operations *old_fops;
 
        DRM_DEBUG("\n");
 
 
        drm_device_t *dev = priv->head->dev;
        drm_i810_buf_priv_t *buf_priv = buf->dev_private;
        drm_i810_private_t *dev_priv = dev->dev_private;
-       struct file_operations *old_fops;
+       const struct file_operations *old_fops;
        int retcode = 0;
 
        if (buf_priv->currently_mapped == I810_BUF_MAPPED)
 
        drm_device_t *dev = priv->head->dev;
        drm_i830_buf_priv_t *buf_priv = buf->dev_private;
        drm_i830_private_t *dev_priv = dev->dev_private;
-       struct file_operations *old_fops;
+       const struct file_operations *old_fops;
        unsigned long virtual;
        int retcode = 0;
 
 
        unsigned int            minor;
        char                    *name;
        umode_t                 mode;
-       struct file_operations  *fops;
+       const struct file_operations    *fops;
 } devlist[] = { /* list of minor devices */
        {1, "mem",     S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops},
        {2, "kmem",    S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
 
        int minor = iminor(inode);
        struct miscdevice *c;
        int err = -ENODEV;
-       struct file_operations *old_fops, *new_fops = NULL;
+       const struct file_operations *old_fops, *new_fops = NULL;
        
        down(&misc_sem);
        
 
 static int input_open_file(struct inode *inode, struct file *file)
 {
        struct input_handler *handler = input_table[iminor(inode) >> 5];
-       struct file_operations *old_fops, *new_fops = NULL;
+       const struct file_operations *old_fops, *new_fops = NULL;
        int err;
 
        /* No load-on-demand here? */
 
 };
 
 static void
-create_seq_entry(char *name, mode_t mode, struct file_operations *f)
+create_seq_entry(char *name, mode_t mode, const struct file_operations *f)
 {
        struct proc_dir_entry *entry;
        entry = create_proc_entry(name, mode, NULL);
 
 
        if (dvbdev && dvbdev->fops) {
                int err = 0;
-               struct file_operations *old_fops;
+               const struct file_operations *old_fops;
 
                file->private_data = dvbdev;
                old_fops = file->f_op;
 
        unsigned int minor = iminor(inode);
        int err = 0;
        struct video_device *vfl;
-       struct file_operations *old_fops;
+       const struct file_operations *old_fops;
 
        if(minor>=VIDEO_NUM_DEVICES)
                return -ENODEV;
 
 typedef struct _i2o_proc_entry_t {
        char *name;             /* entry name */
        mode_t mode;            /* mode */
-       struct file_operations *fops;   /* open function */
+       const struct file_operations *fops;     /* open function */
 } i2o_proc_entry;
 
 /* global I2O /proc/i2o entry */
 
 
 
 static struct dentry * __oprofilefs_create_file(struct super_block * sb,
-       struct dentry * root, char const * name, struct file_operations * fops,
+       struct dentry * root, char const * name, const struct file_operations * fops,
        int perm)
 {
        struct dentry * dentry;
 
  
 int oprofilefs_create_file(struct super_block * sb, struct dentry * root,
-       char const * name, struct file_operations * fops)
+       char const * name, const struct file_operations * fops)
 {
        if (!__oprofilefs_create_file(sb, root, name, fops, 0644))
                return -EFAULT;
 
 
 int oprofilefs_create_file_perm(struct super_block * sb, struct dentry * root,
-       char const * name, struct file_operations * fops, int perm)
+       char const * name, const struct file_operations * fops, int perm)
 {
        if (!__oprofilefs_create_file(sb, root, name, fops, perm))
                return -EFAULT;
 
        unsigned int minor = iminor(inode);
        int err = 0;
        struct phone_device *p;
-       struct file_operations *old_fops, *new_fops = NULL;
+       const struct file_operations *old_fops, *new_fops = NULL;
 
        if (minor >= PHONE_NUM_DEVICES)
                return -ENODEV;
 
 #include "usb.h"
 
 #define MAX_USB_MINORS 256
-static struct file_operations *usb_minors[MAX_USB_MINORS];
+static const struct file_operations *usb_minors[MAX_USB_MINORS];
 static DEFINE_SPINLOCK(minor_lock);
 
 static int usb_open(struct inode * inode, struct file * file)
 {
        int minor = iminor(inode);
-       struct file_operations *c;
+       const struct file_operations *c;
        int err = -ENODEV;
-       struct file_operations *old_fops, *new_fops = NULL;
+       const struct file_operations *old_fops, *new_fops = NULL;
 
        spin_lock (&minor_lock);
        c = usb_minors[minor];
 
 
 static struct inode *
 gadgetfs_create_file (struct super_block *sb, char const *name,
-               void *data, struct file_operations *fops,
+               void *data, const struct file_operations *fops,
                struct dentry **dentry_p);
 
 static int activate_ep_files (struct dev_data *dev)
 
 static struct inode *
 gadgetfs_make_inode (struct super_block *sb,
-               void *data, struct file_operations *fops,
+               void *data, const struct file_operations *fops,
                int mode)
 {
        struct inode *inode = new_inode (sb);
  */
 static struct inode *
 gadgetfs_create_file (struct super_block *sb, char const *name,
-               void *data, struct file_operations *fops,
+               void *data, const struct file_operations *fops,
                struct dentry **dentry_p)
 {
        struct dentry   *dentry;
 
 }
 
 int register_chrdev(unsigned int major, const char *name,
-                   struct file_operations *fops)
+                   const struct file_operations *fops)
 {
        struct char_device_struct *cd;
        struct cdev *cdev;
        return p;
 }
 
-void cdev_init(struct cdev *cdev, struct file_operations *fops)
+void cdev_init(struct cdev *cdev, const struct file_operations *fops)
 {
        memset(cdev, 0, sizeof *cdev);
        INIT_LIST_HEAD(&cdev->list);
 
  */
 struct dentry *debugfs_create_file(const char *name, mode_t mode,
                                   struct dentry *parent, void *data,
-                                  struct file_operations *fops)
+                                  const struct file_operations *fops)
 {
        struct dentry *dentry = NULL;
        int error;
 
 {
        static struct address_space_operations empty_aops;
        static struct inode_operations empty_iops;
-       static struct file_operations empty_fops;
+       static const struct file_operations empty_fops;
        struct inode *inode;
 
        if (sb->s_op->alloc_inode)
 
  * after it.
  */
 static inline int nfsd_dosync(struct file *filp, struct dentry *dp,
-                             struct file_operations *fop)
+                             const struct file_operations *fop)
 {
        struct inode *inode = dp->d_inode;
        int (*fsync) (struct file *, struct dentry *, int);
 
                struct file * filp = list_entry(p, struct file, f_u.fu_list);
                struct dentry * dentry = filp->f_dentry;
                struct inode * inode;
-               struct file_operations *fops;
+               const struct file_operations *fops;
 
                if (dentry->d_op != &proc_dentry_operations)
                        continue;
 
 
 #endif
 
-extern void create_seq_entry(char *name, mode_t mode, struct file_operations *f);
+extern void create_seq_entry(char *name, mode_t mode, const struct file_operations *f);
 extern int proc_exe_link(struct inode *, struct dentry **, struct vfsmount **);
 extern int proc_tid_stat(struct task_struct *,  char *);
 extern int proc_tgid_stat(struct task_struct *, char *);
 
 
 struct proc_dir_entry *proc_root_kcore;
 
-void create_seq_entry(char *name, mode_t mode, struct file_operations *f)
+void create_seq_entry(char *name, mode_t mode, const struct file_operations *f)
 {
        struct proc_dir_entry *entry;
        entry = create_proc_entry(name, mode, NULL);
 
                for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
                        unsigned long in, out, ex, all_bits, bit = 1, mask, j;
                        unsigned long res_in = 0, res_out = 0, res_ex = 0;
-                       struct file_operations *f_op = NULL;
+                       const struct file_operations *f_op = NULL;
                        struct file *file = NULL;
 
                        in = *inp++; out = *outp++; ex = *exp++;
 
 struct cdev {
        struct kobject kobj;
        struct module *owner;
-       struct file_operations *ops;
+       const struct file_operations *ops;
        struct list_head list;
        dev_t dev;
        unsigned int count;
 };
 
-void cdev_init(struct cdev *, struct file_operations *);
+void cdev_init(struct cdev *, const struct file_operations *);
 
 struct cdev *cdev_alloc(void);
 
 
 #if defined(CONFIG_DEBUG_FS)
 struct dentry *debugfs_create_file(const char *name, mode_t mode,
                                   struct dentry *parent, void *data,
-                                  struct file_operations *fops);
+                                  const struct file_operations *fops);
 
 struct dentry *debugfs_create_dir(const char *name, struct dentry *parent);
 
 
        struct mutex            i_mutex;
        struct rw_semaphore     i_alloc_sem;
        struct inode_operations *i_op;
-       struct file_operations  *i_fop; /* former ->i_op->default_file_ops */
+       const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
        struct super_block      *i_sb;
        struct file_lock        *i_flock;
        struct address_space    *i_mapping;
        } f_u;
        struct dentry           *f_dentry;
        struct vfsmount         *f_vfsmnt;
-       struct file_operations  *f_op;
+       const struct file_operations    *f_op;
        atomic_t                f_count;
        unsigned int            f_flags;
        mode_t                  f_mode;
 extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
 extern int register_chrdev_region(dev_t, unsigned, const char *);
 extern int register_chrdev(unsigned int, const char *,
-                          struct file_operations *);
+                          const struct file_operations *);
 extern int unregister_chrdev(unsigned int, const char *);
 extern void unregister_chrdev_region(dev_t, unsigned);
 extern int chrdev_open(struct inode *, struct file *);
 
        struct input_handle* (*connect)(struct input_handler *handler, struct input_dev *dev, struct input_device_id *id);
        void (*disconnect)(struct input_handle *handle);
 
-       struct file_operations *fops;
+       const struct file_operations *fops;
        int minor;
        char *name;
 
 
 struct miscdevice  {
        int minor;
        const char *name;
-       struct file_operations *fops;
+       const struct file_operations *fops;
        struct list_head list;
        struct device *dev;
        struct class_device *class;
 
  * the specified file operations.
  */
 int oprofilefs_create_file(struct super_block * sb, struct dentry * root,
-       char const * name, struct file_operations * fops);
+       char const * name, const struct file_operations * fops);
 
 int oprofilefs_create_file_perm(struct super_block * sb, struct dentry * root,
-       char const * name, struct file_operations * fops, int perm);
+       char const * name, const struct file_operations * fops, int perm);
  
 /** Create a file for read/write access to an unsigned long. */
 int oprofilefs_create_ulong(struct super_block * sb, struct dentry * root,
 
        gid_t gid;
        loff_t size;
        struct inode_operations * proc_iops;
-       struct file_operations * proc_fops;
+       const struct file_operations * proc_fops;
        get_info_t *get_info;
        struct module *owner;
        struct proc_dir_entry *next, *parent, *subdir;
 }
 
 static inline struct proc_dir_entry *proc_net_fops_create(const char *name,
-       mode_t mode, struct file_operations *fops)
+       mode_t mode, const struct file_operations *fops)
 {
        struct proc_dir_entry *res = create_proc_entry(name, mode, proc_net);
        if (res)
 
  */
  
 struct device;
-extern int register_sound_special(struct file_operations *fops, int unit);
-extern int register_sound_special_device(struct file_operations *fops, int unit, struct device *dev);
-extern int register_sound_mixer(struct file_operations *fops, int dev);
-extern int register_sound_midi(struct file_operations *fops, int dev);
-extern int register_sound_dsp(struct file_operations *fops, int dev);
-extern int register_sound_synth(struct file_operations *fops, int dev);
+extern int register_sound_special(const struct file_operations *fops, int unit);
+extern int register_sound_special_device(const struct file_operations *fops, int unit, struct device *dev);
+extern int register_sound_mixer(const struct file_operations *fops, int dev);
+extern int register_sound_midi(const struct file_operations *fops, int dev);
+extern int register_sound_dsp(const struct file_operations *fops, int dev);
+extern int register_sound_synth(const struct file_operations *fops, int dev);
 
 extern void unregister_sound_special(int unit);
 extern void unregister_sound_mixer(int unit);
 
 void                   rpc_proc_unregister(const char *);
 void                   rpc_proc_zero(struct rpc_program *);
 struct proc_dir_entry *        svc_proc_register(struct svc_stat *,
-                                         struct file_operations *);
+                                         const struct file_operations *);
 void                   svc_proc_unregister(const char *);
 
 void                   svc_seq_show(struct seq_file *,
 static inline void rpc_proc_zero(struct rpc_program *p) {}
 
 static inline struct proc_dir_entry *svc_proc_register(struct svc_stat *s,
-                                                      struct file_operations *f) { return NULL; }
+                                                      const struct file_operations *f) { return NULL; }
 static inline void svc_proc_unregister(const char *p) {}
 
 static inline void svc_seq_show(struct seq_file *seq,
 
  */
 struct usb_class_driver {
        char *name;
-       struct file_operations *fops;
+       const struct file_operations *fops;
        int minor_base;
 };
 
 
        int minor;
 
        /* device ops + callbacks */
-       struct file_operations *fops;
+       const struct file_operations *fops;
        void (*release)(struct video_device *vfd);
 
 
 
        int type;                       /* SNDRV_DEVICE_TYPE_XXX */
        int card;                       /* card number */
        int device;                     /* device number */
-       struct file_operations *f_ops;  /* file operations */
+       const struct file_operations *f_ops;    /* file operations */
        void *private_data;             /* private data for f_ops->open */
        char name[0];                   /* device name (keep at the end of
                                                                structure) */
 void snd_request_card(int card);
 
 int snd_register_device(int type, struct snd_card *card, int dev,
-                       struct file_operations *f_ops, void *private_data,
+                       const struct file_operations *f_ops, void *private_data,
                        const char *name);
 int snd_unregister_device(int type, struct snd_card *card, int dev);
 void *snd_lookup_minor_data(unsigned int minor, int type);
 
 #ifdef CONFIG_SND_OSSEMUL
 int snd_register_oss_device(int type, struct snd_card *card, int dev,
-                           struct file_operations *f_ops, void *private_data,
+                           const struct file_operations *f_ops, void *private_data,
                            const char *name);
 int snd_unregister_oss_device(int type, struct snd_card *card, int dev);
 void *snd_lookup_oss_minor_data(unsigned int minor, int type);
 
  */
 struct rpc_filelist {
        char *name;
-       struct file_operations *i_fop;
+       const struct file_operations *i_fop;
        int mode;
 };
 
 
  * Register/unregister RPC proc files
  */
 static inline struct proc_dir_entry *
-do_register(const char *name, void *data, struct file_operations *fops)
+do_register(const char *name, void *data, const struct file_operations *fops)
 {
        struct proc_dir_entry *ent;
 
 }
 
 struct proc_dir_entry *
-svc_proc_register(struct svc_stat *statp, struct file_operations *fops)
+svc_proc_register(struct svc_stat *statp, const struct file_operations *fops)
 {
        return do_register(statp->program->pg_name, statp, fops);
 }
 
        struct snd_monitor_file *mfile;
        struct file *file;
        struct snd_shutdown_f_ops *s_f_ops;
-       struct file_operations *f_ops, *old_f_ops;
+       struct file_operations *f_ops;
+       const struct file_operations *old_f_ops;
        int err;
 
        spin_lock(&card->files_lock);
 
 {
        unsigned int minor = iminor(inode);
        struct snd_minor *mptr = NULL;
-       struct file_operations *old_fops;
+       const struct file_operations *old_fops;
        int err = 0;
 
        if (minor >= ARRAY_SIZE(snd_minors))
  * Retrurns zero if successful, or a negative error code on failure.
  */
 int snd_register_device(int type, struct snd_card *card, int dev,
-                       struct file_operations *f_ops, void *private_data,
+                       const struct file_operations *f_ops, void *private_data,
                        const char *name)
 {
        int minor;
 
 }
 
 int snd_register_oss_device(int type, struct snd_card *card, int dev,
-                           struct file_operations *f_ops, void *private_data,
+                           const struct file_operations *f_ops, void *private_data,
                            const char *name)
 {
        int minor = snd_oss_kernel_minor(type, card, dev);
 
 struct sound_unit
 {
        int unit_minor;
-       struct file_operations *unit_fops;
+       const struct file_operations *unit_fops;
        struct sound_unit *next;
        char name[32];
 };
  *     join into it. Called with the lock asserted
  */
 
-static int __sound_insert_unit(struct sound_unit * s, struct sound_unit **list, struct file_operations *fops, int index, int low, int top)
+static int __sound_insert_unit(struct sound_unit * s, struct sound_unit **list, const struct file_operations *fops, int index, int low, int top)
 {
        int n=low;
 
  *     list. Acquires locks as needed
  */
 
-static int sound_insert_unit(struct sound_unit **list, struct file_operations *fops, int index, int low, int top, const char *name, umode_t mode, struct device *dev)
+static int sound_insert_unit(struct sound_unit **list, const struct file_operations *fops, int index, int low, int top, const char *name, umode_t mode, struct device *dev)
 {
        struct sound_unit *s = kmalloc(sizeof(*s), GFP_KERNEL);
        int r;
  *     a negative error code is returned.
  */
  
-int register_sound_special_device(struct file_operations *fops, int unit,
+int register_sound_special_device(const struct file_operations *fops, int unit,
                                  struct device *dev)
 {
        const int chain = unit % SOUND_STEP;
  
 EXPORT_SYMBOL(register_sound_special_device);
 
-int register_sound_special(struct file_operations *fops, int unit)
+int register_sound_special(const struct file_operations *fops, int unit)
 {
        return register_sound_special_device(fops, unit, NULL);
 }
  *     number is returned, on failure a negative error code is returned.
  */
 
-int register_sound_mixer(struct file_operations *fops, int dev)
+int register_sound_mixer(const struct file_operations *fops, int dev)
 {
        return sound_insert_unit(&chains[0], fops, dev, 0, 128,
                                 "mixer", S_IRUSR | S_IWUSR, NULL);
  *     number is returned, on failure a negative error code is returned.
  */
 
-int register_sound_midi(struct file_operations *fops, int dev)
+int register_sound_midi(const struct file_operations *fops, int dev)
 {
        return sound_insert_unit(&chains[2], fops, dev, 2, 130,
                                 "midi", S_IRUSR | S_IWUSR, NULL);
  *     and will always allocate them as a matching pair - eg dsp3/audio3
  */
 
-int register_sound_dsp(struct file_operations *fops, int dev)
+int register_sound_dsp(const struct file_operations *fops, int dev)
 {
        return sound_insert_unit(&chains[3], fops, dev, 3, 131,
                                 "dsp", S_IWUSR | S_IRUSR, NULL);
  */
 
 
-int register_sound_synth(struct file_operations *fops, int dev)
+int register_sound_synth(const struct file_operations *fops, int dev)
 {
        return sound_insert_unit(&chains[9], fops, dev, 9, 137,
                                 "synth", S_IRUSR | S_IWUSR, NULL);
        int chain;
        int unit = iminor(inode);
        struct sound_unit *s;
-       struct file_operations *new_fops = NULL;
+       const struct file_operations *new_fops = NULL;
 
        chain=unit&0x0F;
        if(chain==4 || chain==5)        /* dsp/audio/dsp16 */
                 * switching ->f_op in the first place.
                 */
                int err = 0;
-               struct file_operations *old_fops = file->f_op;
+               const struct file_operations *old_fops = file->f_op;
                file->f_op = new_fops;
                spin_unlock(&sound_loader_lock);
                if(file->f_op->open)