All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
339 files changed:
.read = etb_read,
.open = etb_open,
.release = etb_release,
.read = etb_read,
.open = etb_open,
.release = etb_release,
};
static struct miscdevice etb_miscdev = {
};
static struct miscdevice etb_miscdev = {
}
static struct file_operations last_radio_log_fops = {
}
static struct file_operations last_radio_log_fops = {
- .read = last_radio_log_read
+ .read = last_radio_log_read,
+ .llseek = default_llseek,
};
void msm_init_last_radio_log(struct module *owner)
};
void msm_init_last_radio_log(struct module *owner)
static const struct file_operations debug_ops = {
.read = debug_read,
.open = debug_open,
static const struct file_operations debug_ops = {
.read = debug_read,
.open = debug_open,
+ .llseek = default_llseek,
};
static void debug_create(const char *name, mode_t mode,
};
static void debug_create(const char *name, mode_t mode,
static const struct file_operations audmux_debugfs_fops = {
.open = audmux_open_file,
.read = audmux_read_file,
static const struct file_operations audmux_debugfs_fops = {
.open = audmux_open_file,
.read = audmux_read_file,
+ .llseek = default_llseek,
};
static void audmux_debugfs_init(void)
};
static void audmux_debugfs_init(void)
static const struct file_operations fram_fops = {
.owner = THIS_MODULE,
.mmap = fram_mmap,
static const struct file_operations fram_fops = {
.owner = THIS_MODULE,
.mmap = fram_mmap,
.owner = THIS_MODULE,
.read = kgdb_test_proc_read,
.write = kgdb_test_proc_write,
.owner = THIS_MODULE,
.read = kgdb_test_proc_read,
.write = kgdb_test_proc_write,
};
static int __init kgdbtest_init(void)
};
static int __init kgdbtest_init(void)
static const struct file_operations coreb_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = coreb_ioctl,
static const struct file_operations coreb_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = coreb_ioctl,
};
static struct miscdevice coreb_dev = {
};
static struct miscdevice coreb_dev = {
static const struct file_operations rtc_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = rtc_unlocked_ioctl,
static const struct file_operations rtc_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = rtc_unlocked_ioctl,
};
/* Probe for the chip by writing something to its RAM and try reading it back. */
};
/* Probe for the chip by writing something to its RAM and try reading it back. */
.write = gpio_write,
.open = gpio_open,
.release = gpio_release,
.write = gpio_write,
.open = gpio_open,
.release = gpio_release,
};
static void ioif_watcher(const unsigned int gpio_in_available,
};
static void ioif_watcher(const unsigned int gpio_in_available,
.unlocked_ioctl = i2c_ioctl,
.open = i2c_open,
.release = i2c_release,
.unlocked_ioctl = i2c_ioctl,
.open = i2c_open,
.release = i2c_release,
static const struct file_operations pcf8563_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = pcf8563_unlocked_ioctl,
static const struct file_operations pcf8563_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = pcf8563_unlocked_ioctl,
.poll = sync_serial_poll,
.unlocked_ioctl = sync_serial_ioctl,
.open = sync_serial_open,
.poll = sync_serial_poll,
.unlocked_ioctl = sync_serial_ioctl,
.open = sync_serial_open,
- .release = sync_serial_release
+ .release = sync_serial_release,
+ .llseek = noop_llseek,
};
static int __init etrax_sync_serial_init(void)
};
static int __init etrax_sync_serial_init(void)
.owner = THIS_MODULE,
.open = cryptocop_open,
.release = cryptocop_release,
.owner = THIS_MODULE,
.open = cryptocop_open,
.release = cryptocop_release,
- .unlocked_ioctl = cryptocop_ioctl
+ .unlocked_ioctl = cryptocop_ioctl,
+ .llseek = noop_llseek,
.unlocked_ioctl = i2c_ioctl,
.open = i2c_open,
.release = i2c_release,
.unlocked_ioctl = i2c_ioctl,
.open = i2c_open,
.release = i2c_release,
};
static int __init i2c_init(void)
};
static int __init i2c_init(void)
.write = gpio_write,
.open = gpio_open,
.release = gpio_release,
.write = gpio_write,
.open = gpio_open,
.release = gpio_release,
};
#ifdef CONFIG_ETRAX_VIRTUAL_GPIO
};
#ifdef CONFIG_ETRAX_VIRTUAL_GPIO
.write = gpio_write,
.open = gpio_open,
.release = gpio_release,
.write = gpio_write,
.open = gpio_open,
.release = gpio_release,
};
#ifdef CONFIG_ETRAX_VIRTUAL_GPIO
};
#ifdef CONFIG_ETRAX_VIRTUAL_GPIO
static const struct file_operations pcf8563_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = pcf8563_unlocked_ioctl,
static const struct file_operations pcf8563_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = pcf8563_unlocked_ioctl,
.poll = sync_serial_poll,
.unlocked_ioctl = sync_serial_ioctl,
.open = sync_serial_open,
.poll = sync_serial_poll,
.unlocked_ioctl = sync_serial_ioctl,
.open = sync_serial_open,
- .release = sync_serial_release
+ .release = sync_serial_release,
+ .llseek = noop_llseek,
};
static int __init etrax_sync_serial_init(void)
};
static int __init etrax_sync_serial_init(void)
static const struct file_operations cris_proc_profile_operations = {
.read = read_cris_profile,
.write = write_cris_profile,
static const struct file_operations cris_proc_profile_operations = {
.read = read_cris_profile,
.write = write_cris_profile,
+ .llseek = default_llseek,
};
static int __init init_cris_profile(void)
};
static int __init init_cris_profile(void)
static const struct file_operations salinfo_event_fops = {
.open = salinfo_event_open,
.read = salinfo_event_read,
static const struct file_operations salinfo_event_fops = {
.open = salinfo_event_open,
.read = salinfo_event_read,
.release = salinfo_log_release,
.read = salinfo_log_read,
.write = salinfo_log_write,
.release = salinfo_log_release,
.read = salinfo_log_read,
.write = salinfo_log_write,
+ .llseek = default_llseek,
static const struct file_operations sn_hwperf_fops = {
.unlocked_ioctl = sn_hwperf_ioctl,
static const struct file_operations sn_hwperf_fops = {
.unlocked_ioctl = sn_hwperf_ioctl,
};
static struct miscdevice sn_hwperf_dev = {
};
static struct miscdevice sn_hwperf_dev = {
.unlocked_ioctl = rtc_ioctl,
.open = rtc_open,
.release = rtc_release,
.unlocked_ioctl = rtc_ioctl,
.open = rtc_open,
.release = rtc_release,
};
static struct miscdevice rtc_dev = {
};
static struct miscdevice rtc_dev = {
.unlocked_ioctl = rtc_ioctl,
.open = rtc_open,
.release = rtc_release,
.unlocked_ioctl = rtc_ioctl,
.open = rtc_open,
.release = rtc_release,
};
static struct miscdevice rtc_dev=
};
static struct miscdevice rtc_dev=
.release = file_release,
.write = file_write,
.read = file_read,
.release = file_release,
.write = file_write,
.read = file_read,
+ .poll = file_poll,
+ .llseek = noop_llseek,
};
static struct irqaction rtlx_irq = {
};
static struct irqaction rtlx_irq = {
.owner = THIS_MODULE,
.open = vpe_open,
.release = vpe_release,
.owner = THIS_MODULE,
.open = vpe_open,
.release = vpe_release,
+ .write = vpe_write,
+ .llseek = noop_llseek,
};
/* module wrapper entry points */
};
/* module wrapper entry points */
.unlocked_ioctl = sbprof_tb_ioctl,
.compat_ioctl = sbprof_tb_ioctl,
.mmap = NULL,
.unlocked_ioctl = sbprof_tb_ioctl,
.compat_ioctl = sbprof_tb_ioctl,
.mmap = NULL,
+ .llseek = default_llseek,
};
static struct class *tb_class;
};
static struct class *tb_class;
.write = lparcfg_write,
.open = lparcfg_open,
.release = single_release,
.write = lparcfg_write,
.open = lparcfg_open,
.release = single_release,
};
static int __init lparcfg_init(void)
};
static int __init lparcfg_init(void)
.write = rtas_flash_write,
.open = rtas_excl_open,
.release = rtas_flash_release,
.write = rtas_flash_write,
.open = rtas_excl_open,
.release = rtas_flash_release,
+ .llseek = default_llseek,
};
static const struct file_operations manage_flash_operations = {
};
static const struct file_operations manage_flash_operations = {
.write = manage_flash_write,
.open = rtas_excl_open,
.release = rtas_excl_release,
.write = manage_flash_write,
.open = rtas_excl_open,
.release = rtas_excl_release,
+ .llseek = default_llseek,
};
static const struct file_operations validate_flash_operations = {
};
static const struct file_operations validate_flash_operations = {
.write = validate_flash_write,
.open = rtas_excl_open,
.release = validate_flash_release,
.write = validate_flash_write,
.open = rtas_excl_open,
.release = validate_flash_release,
+ .llseek = default_llseek,
};
static int __init rtas_flash_init(void)
};
static int __init rtas_flash_init(void)
.poll = rtas_log_poll,
.open = rtas_log_open,
.release = rtas_log_release,
.poll = rtas_log_poll,
.open = rtas_log_open,
.release = rtas_log_release,
};
static int enable_surveillance(int timeout)
};
static int enable_surveillance(int timeout)
static const struct file_operations proc_vmlinux_operations = {
.write = proc_mf_change_vmlinux,
static const struct file_operations proc_vmlinux_operations = {
.write = proc_mf_change_vmlinux,
+ .llseek = default_llseek,
};
static int __init mf_proc_init(void)
};
static int __init mf_proc_init(void)
}
static const struct file_operations ofdt_fops = {
}
static const struct file_operations ofdt_fops = {
+ .write = ofdt_write,
+ .llseek = noop_llseek,
};
/* create /proc/powerpc/ofdt write-only by root */
};
/* create /proc/powerpc/ofdt write-only by root */
.write = scanlog_write,
.open = scanlog_open,
.release = scanlog_release,
.write = scanlog_write,
.open = scanlog_open,
.release = scanlog_release,
};
static int __init scanlog_init(void)
};
static int __init scanlog_init(void)
.open = &prng_open,
.release = NULL,
.read = &prng_read,
.open = &prng_open,
.release = NULL,
.read = &prng_read,
};
static struct miscdevice prng_dev = {
};
static struct miscdevice prng_dev = {
.open = dbfs_d204_open,
.read = dbfs_d204_read,
.release = dbfs_d204_release,
.open = dbfs_d204_open,
.read = dbfs_d204_read,
.release = dbfs_d204_release,
};
static int hypfs_dbfs_init(void)
};
static int hypfs_dbfs_init(void)
.open = dbfs_d2fc_open,
.read = dbfs_d2fc_read,
.release = dbfs_d2fc_release,
.open = dbfs_d2fc_open,
.read = dbfs_d2fc_read,
.release = dbfs_d2fc_release,
};
int hypfs_vm_init(void)
};
int hypfs_vm_init(void)
.write = do_sync_write,
.aio_read = hypfs_aio_read,
.aio_write = hypfs_aio_write,
.write = do_sync_write,
.aio_read = hypfs_aio_read,
.aio_write = hypfs_aio_write,
};
static struct file_system_type hypfs_type = {
};
static struct file_system_type hypfs_type = {
.write = debug_input,
.open = debug_open,
.release = debug_close,
.write = debug_input,
.open = debug_open,
.release = debug_close,
};
static struct dentry *debug_debugfs_root_entry;
};
static struct dentry *debug_debugfs_root_entry;
.open = gio_open, /* open */
.release = gio_close, /* release */
.unlocked_ioctl = gio_ioctl,
.open = gio_open, /* open */
.release = gio_close, /* release */
.unlocked_ioctl = gio_ioctl,
};
static int __init gio_init(void)
};
static int __init gio_init(void)
.unlocked_ioctl = apc_ioctl,
.open = apc_open,
.release = apc_release,
.unlocked_ioctl = apc_ioctl,
.open = apc_open,
.release = apc_release,
};
static struct miscdevice apc_miscdev = { APC_MINOR, APC_DEVNAME, &apc_fops };
};
static struct miscdevice apc_miscdev = { APC_MINOR, APC_DEVNAME, &apc_fops };
static const struct file_operations mdesc_fops = {
.read = mdesc_read,
.owner = THIS_MODULE,
static const struct file_operations mdesc_fops = {
.read = mdesc_read,
.owner = THIS_MODULE,
};
static struct miscdevice mdesc_misc = {
};
static struct miscdevice mdesc_misc = {
#endif
.flush = hardwall_flush,
.release = hardwall_release,
#endif
.flush = hardwall_flush,
.release = hardwall_release,
};
static struct cdev hardwall_dev;
};
static struct cdev hardwall_dev;
.unlocked_ioctl = harddog_ioctl,
.open = harddog_open,
.release = harddog_release,
.unlocked_ioctl = harddog_ioctl,
.open = harddog_open,
.release = harddog_release,
};
static struct miscdevice harddog_miscdev = {
};
static struct miscdevice harddog_miscdev = {
static const struct file_operations mconsole_proc_fops = {
.owner = THIS_MODULE,
.write = mconsole_proc_write,
static const struct file_operations mconsole_proc_fops = {
.owner = THIS_MODULE,
.write = mconsole_proc_write,
};
static int create_proc_mconsole(void)
};
static int create_proc_mconsole(void)
.mmap = mmapper_mmap,
.open = mmapper_open,
.release = mmapper_release,
.mmap = mmapper_mmap,
.open = mmapper_open,
.release = mmapper_release,
+ .llseek = default_llseek,
.owner = THIS_MODULE,
.open = rng_dev_open,
.read = rng_dev_read,
.owner = THIS_MODULE,
.open = rng_dev_open,
.read = rng_dev_read,
};
/* rng_init shouldn't be called more than once at boot time */
};
/* rng_init shouldn't be called more than once at boot time */
.unlocked_ioctl = do_ioctl,
.open = do_open,
.release = do_release,
.unlocked_ioctl = do_ioctl,
.open = do_open,
.release = do_release,
};
static struct miscdevice apm_device = {
};
static struct miscdevice apm_device = {
.release = seq_release,
.read = seq_read,
.write = severities_coverage_write,
.release = seq_release,
.read = seq_read,
.write = severities_coverage_write,
};
static int __init severities_debugfs_init(void)
};
static int __init severities_debugfs_init(void)
.read = mce_read,
.poll = mce_poll,
.unlocked_ioctl = mce_ioctl,
.read = mce_read,
.poll = mce_poll,
.unlocked_ioctl = mce_ioctl,
};
EXPORT_SYMBOL_GPL(mce_chrdev_ops);
};
EXPORT_SYMBOL_GPL(mce_chrdev_ops);
static const struct file_operations fops_setup_data = {
.read = setup_data_read,
.open = setup_data_open,
static const struct file_operations fops_setup_data = {
.read = setup_data_read,
.open = setup_data_open,
+ .llseek = default_llseek,
.owner = THIS_MODULE,
.write = microcode_write,
.open = microcode_open,
.owner = THIS_MODULE,
.write = microcode_write,
.open = microcode_open,
};
static struct miscdevice microcode_dev = {
};
static struct miscdevice microcode_dev = {
.open = tunables_open,
.read = tunables_read,
.write = tunables_write,
.open = tunables_open,
.read = tunables_read,
.write = tunables_write,
+ .llseek = default_llseek,
};
static int __init uv_ptc_init(void)
};
static int __init uv_ptc_init(void)
.open = u32_array_open,
.release= xen_array_release,
.read = u32_array_read,
.open = u32_array_open,
.release= xen_array_release,
.read = u32_array_read,
};
struct dentry *xen_debugfs_create_u32_array(const char *name, mode_t mode,
};
struct dentry *xen_debugfs_create_u32_array(const char *name, mode_t mode,
.release = bsg_release,
.unlocked_ioctl = bsg_ioctl,
.owner = THIS_MODULE,
.release = bsg_release,
.unlocked_ioctl = bsg_ioctl,
.owner = THIS_MODULE,
+ .llseek = default_llseek,
};
void bsg_unregister_queue(struct request_queue *q)
};
void bsg_unregister_queue(struct request_queue *q)
.read = erst_dbg_read,
.write = erst_dbg_write,
.unlocked_ioctl = erst_dbg_ioctl,
.read = erst_dbg_read,
.write = erst_dbg_write,
.unlocked_ioctl = erst_dbg_ioctl,
};
static struct miscdevice erst_dbg_dev = {
};
static struct miscdevice erst_dbg_dev = {
static const struct file_operations cm_fops = {
.write = cm_write,
static const struct file_operations cm_fops = {
.write = cm_write,
+ .llseek = default_llseek,
};
int __init acpi_debugfs_init(void)
};
int __init acpi_debugfs_init(void)
.open = acpi_ec_open_io,
.read = acpi_ec_read_io,
.write = acpi_ec_write_io,
.open = acpi_ec_open_io,
.read = acpi_ec_read_io,
.write = acpi_ec_write_io,
+ .llseek = default_llseek,
};
int acpi_ec_add_debugfs(struct acpi_ec *ec, unsigned int ec_device_count)
};
int acpi_ec_add_debugfs(struct acpi_ec *ec, unsigned int ec_device_count)
.read = acpi_system_read_event,
.release = acpi_system_close_event,
.poll = acpi_system_poll_event,
.read = acpi_system_read_event,
.release = acpi_system_close_event,
.poll = acpi_system_poll_event,
+ .llseek = default_llseek,
};
#endif /* CONFIG_ACPI_PROC_EVENT */
};
#endif /* CONFIG_ACPI_PROC_EVENT */
static const struct file_operations DAC960_gam_fops = {
.owner = THIS_MODULE,
static const struct file_operations DAC960_gam_fops = {
.owner = THIS_MODULE,
- .unlocked_ioctl = DAC960_gam_ioctl
+ .unlocked_ioctl = DAC960_gam_ioctl,
+ .llseek = noop_llseek,
};
static struct miscdevice DAC960_gam_dev = {
};
static struct miscdevice DAC960_gam_dev = {
.open = aoechr_open,
.release = aoechr_rel,
.owner = THIS_MODULE,
.open = aoechr_open,
.release = aoechr_rel,
.owner = THIS_MODULE,
};
static char *aoe_devnode(struct device *dev, mode_t *mode)
};
static char *aoe_devnode(struct device *dev, mode_t *mode)
.write = pg_write,
.open = pg_open,
.release = pg_release,
.write = pg_write,
.open = pg_open,
.release = pg_release,
};
static void pg_init_units(void)
};
static void pg_init_units(void)
.unlocked_ioctl = pt_ioctl,
.open = pt_open,
.release = pt_release,
.unlocked_ioctl = pt_ioctl,
.open = pt_open,
.release = pt_release,
};
/* sysfs class support */
};
/* sysfs class support */
.compat_ioctl = pkt_ctl_compat_ioctl,
#endif
.owner = THIS_MODULE,
.compat_ioctl = pkt_ctl_compat_ioctl,
#endif
.owner = THIS_MODULE,
};
static struct miscdevice pkt_misc = {
};
static struct miscdevice pkt_misc = {
.read = btmrvl_hscfgcmd_read,
.write = btmrvl_hscfgcmd_write,
.open = btmrvl_open_generic,
.read = btmrvl_hscfgcmd_read,
.write = btmrvl_hscfgcmd_write,
.open = btmrvl_open_generic,
+ .llseek = default_llseek,
};
static ssize_t btmrvl_psmode_write(struct file *file, const char __user *ubuf,
};
static ssize_t btmrvl_psmode_write(struct file *file, const char __user *ubuf,
.read = btmrvl_psmode_read,
.write = btmrvl_psmode_write,
.open = btmrvl_open_generic,
.read = btmrvl_psmode_read,
.write = btmrvl_psmode_write,
.open = btmrvl_open_generic,
+ .llseek = default_llseek,
};
static ssize_t btmrvl_pscmd_write(struct file *file, const char __user *ubuf,
};
static ssize_t btmrvl_pscmd_write(struct file *file, const char __user *ubuf,
.read = btmrvl_pscmd_read,
.write = btmrvl_pscmd_write,
.open = btmrvl_open_generic,
.read = btmrvl_pscmd_read,
.write = btmrvl_pscmd_write,
.open = btmrvl_open_generic,
+ .llseek = default_llseek,
};
static ssize_t btmrvl_gpiogap_write(struct file *file, const char __user *ubuf,
};
static ssize_t btmrvl_gpiogap_write(struct file *file, const char __user *ubuf,
.read = btmrvl_gpiogap_read,
.write = btmrvl_gpiogap_write,
.open = btmrvl_open_generic,
.read = btmrvl_gpiogap_read,
.write = btmrvl_gpiogap_write,
.open = btmrvl_open_generic,
+ .llseek = default_llseek,
};
static ssize_t btmrvl_hscmd_write(struct file *file, const char __user *ubuf,
};
static ssize_t btmrvl_hscmd_write(struct file *file, const char __user *ubuf,
.read = btmrvl_hscmd_read,
.write = btmrvl_hscmd_write,
.open = btmrvl_open_generic,
.read = btmrvl_hscmd_read,
.write = btmrvl_hscmd_write,
.open = btmrvl_open_generic,
+ .llseek = default_llseek,
};
static ssize_t btmrvl_hsmode_write(struct file *file, const char __user *ubuf,
};
static ssize_t btmrvl_hsmode_write(struct file *file, const char __user *ubuf,
.read = btmrvl_hsmode_read,
.write = btmrvl_hsmode_write,
.open = btmrvl_open_generic,
.read = btmrvl_hsmode_read,
.write = btmrvl_hsmode_write,
.open = btmrvl_open_generic,
+ .llseek = default_llseek,
};
static ssize_t btmrvl_curpsmode_read(struct file *file, char __user *userbuf,
};
static ssize_t btmrvl_curpsmode_read(struct file *file, char __user *userbuf,
static const struct file_operations btmrvl_curpsmode_fops = {
.read = btmrvl_curpsmode_read,
.open = btmrvl_open_generic,
static const struct file_operations btmrvl_curpsmode_fops = {
.read = btmrvl_curpsmode_read,
.open = btmrvl_open_generic,
+ .llseek = default_llseek,
};
static ssize_t btmrvl_psstate_read(struct file *file, char __user * userbuf,
};
static ssize_t btmrvl_psstate_read(struct file *file, char __user * userbuf,
static const struct file_operations btmrvl_psstate_fops = {
.read = btmrvl_psstate_read,
.open = btmrvl_open_generic,
static const struct file_operations btmrvl_psstate_fops = {
.read = btmrvl_psstate_read,
.open = btmrvl_open_generic,
+ .llseek = default_llseek,
};
static ssize_t btmrvl_hsstate_read(struct file *file, char __user *userbuf,
};
static ssize_t btmrvl_hsstate_read(struct file *file, char __user *userbuf,
static const struct file_operations btmrvl_hsstate_fops = {
.read = btmrvl_hsstate_read,
.open = btmrvl_open_generic,
static const struct file_operations btmrvl_hsstate_fops = {
.read = btmrvl_hsstate_read,
.open = btmrvl_open_generic,
+ .llseek = default_llseek,
};
static ssize_t btmrvl_txdnldready_read(struct file *file, char __user *userbuf,
};
static ssize_t btmrvl_txdnldready_read(struct file *file, char __user *userbuf,
static const struct file_operations btmrvl_txdnldready_fops = {
.read = btmrvl_txdnldready_read,
.open = btmrvl_open_generic,
static const struct file_operations btmrvl_txdnldready_fops = {
.read = btmrvl_txdnldready_read,
.open = btmrvl_open_generic,
+ .llseek = default_llseek,
};
void btmrvl_debugfs_init(struct hci_dev *hdev)
};
void btmrvl_debugfs_init(struct hci_dev *hdev)
.poll = vhci_poll,
.open = vhci_open,
.release = vhci_release,
.poll = vhci_poll,
.open = vhci_open,
.release = vhci_release,
};
static struct miscdevice vhci_miscdev= {
};
static struct miscdevice vhci_miscdev= {
.unlocked_ioctl = apm_ioctl,
.open = apm_open,
.release = apm_release,
.unlocked_ioctl = apm_ioctl,
.open = apm_open,
.release = apm_release,
};
static struct miscdevice apm_device = {
};
static struct miscdevice apm_device = {
.unlocked_ioctl = bfin_otp_ioctl,
.read = bfin_otp_read,
.write = bfin_otp_write,
.unlocked_ioctl = bfin_otp_ioctl,
.read = bfin_otp_read,
.write = bfin_otp_write,
+ .llseek = default_llseek,
};
static struct miscdevice bfin_otp_misc_device = {
};
static struct miscdevice bfin_otp_misc_device = {
.write = briq_panel_write,
.open = briq_panel_open,
.release = briq_panel_release,
.write = briq_panel_write,
.open = briq_panel_open,
.release = briq_panel_release,
};
static struct miscdevice briq_panel_miscdev = {
};
static struct miscdevice briq_panel_miscdev = {
.owner = THIS_MODULE,
.mmap = bsr_mmap,
.open = bsr_open,
.owner = THIS_MODULE,
.mmap = bsr_mmap,
.open = bsr_open,
};
static void bsr_cleanup_devs(void)
};
static void bsr_cleanup_devs(void)
.owner = THIS_MODULE,
.write = cs5535_gpio_write,
.read = cs5535_gpio_read,
.owner = THIS_MODULE,
.write = cs5535_gpio_write,
.read = cs5535_gpio_read,
- .open = cs5535_gpio_open
+ .open = cs5535_gpio_open,
+ .llseek = no_llseek,
};
static int __init cs5535_gpio_init(void)
};
static int __init cs5535_gpio_init(void)
static const struct file_operations rtc_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = rtc_ioctl,
static const struct file_operations rtc_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = rtc_ioctl,
};
/* Probe for the chip by writing something to its RAM and try reading it back. */
};
/* Probe for the chip by writing something to its RAM and try reading it back. */
.open = ds1620_open,
.read = ds1620_read,
.unlocked_ioctl = ds1620_unlocked_ioctl,
.open = ds1620_open,
.read = ds1620_read,
.unlocked_ioctl = ds1620_unlocked_ioctl,
};
static struct miscdevice ds1620_miscdev = {
};
static struct miscdevice ds1620_miscdev = {
.unlocked_ioctl = dsp56k_ioctl,
.open = dsp56k_open,
.release = dsp56k_release,
.unlocked_ioctl = dsp56k_ioctl,
.open = dsp56k_open,
.release = dsp56k_release,
.unlocked_ioctl = dtlk_ioctl,
.open = dtlk_open,
.release = dtlk_release,
.unlocked_ioctl = dtlk_ioctl,
.open = dtlk_open,
.release = dtlk_release,
};
/* local prototypes */
};
/* local prototypes */
.unlocked_ioctl = gen_rtc_unlocked_ioctl,
.open = gen_rtc_open,
.release = gen_rtc_release,
.unlocked_ioctl = gen_rtc_unlocked_ioctl,
.open = gen_rtc_open,
.release = gen_rtc_release,
};
static struct miscdevice rtc_gen_dev =
};
static struct miscdevice rtc_gen_dev =
.owner = THIS_MODULE,
.open = rng_dev_open,
.read = rng_dev_read,
.owner = THIS_MODULE,
.open = rng_dev_open,
.read = rng_dev_read,
};
static struct miscdevice rng_miscdev = {
};
static struct miscdevice rng_miscdev = {
.write = ip2_ipl_write,
.unlocked_ioctl = ip2_ipl_ioctl,
.open = ip2_ipl_open,
.write = ip2_ipl_write,
.unlocked_ioctl = ip2_ipl_ioctl,
.open = ip2_ipl_open,
};
static unsigned long irq_counter;
};
static unsigned long irq_counter;
.release = ipmi_release,
.fasync = ipmi_fasync,
.poll = ipmi_poll,
.release = ipmi_release,
.fasync = ipmi_fasync,
.poll = ipmi_poll,
};
#define DEVICE_NAME "ipmidev"
};
#define DEVICE_NAME "ipmidev"
.open = ipmi_open,
.release = ipmi_close,
.fasync = ipmi_fasync,
.open = ipmi_open,
.release = ipmi_close,
.fasync = ipmi_fasync,
};
static struct miscdevice ipmi_wdog_miscdev = {
};
static struct miscdevice ipmi_wdog_miscdev = {
.read = stli_memread,
.write = stli_memwrite,
.unlocked_ioctl = stli_memioctl,
.read = stli_memread,
.write = stli_memwrite,
.unlocked_ioctl = stli_memioctl,
+ .llseek = default_llseek,
};
/*****************************************************************************/
};
/*****************************************************************************/
#ifdef CONFIG_PARPORT_1284
.read = lp_read,
#endif
#ifdef CONFIG_PARPORT_1284
.read = lp_read,
#endif
};
/* --- support for console on the line printer ----------------- */
};
/* --- support for console on the line printer ----------------- */
static const struct file_operations oldmem_fops = {
.read = read_oldmem,
.open = open_oldmem,
static const struct file_operations oldmem_fops = {
.read = read_oldmem,
.open = open_oldmem,
+ .llseek = default_llseek,
static const struct file_operations kmsg_fops = {
.write = kmsg_write,
static const struct file_operations kmsg_fops = {
.write = kmsg_write,
};
static const struct memdev {
};
static const struct memdev {
static const struct file_operations memory_fops = {
.open = memory_open,
static const struct file_operations memory_fops = {
.open = memory_open,
};
static char *mem_devnode(struct device *dev, mode_t *mode)
};
static char *mem_devnode(struct device *dev, mode_t *mode)
static const struct file_operations misc_fops = {
.owner = THIS_MODULE,
.open = misc_open,
static const struct file_operations misc_fops = {
.owner = THIS_MODULE,
.open = misc_open,
.owner = THIS_MODULE,
.mmap = mmtimer_mmap,
.unlocked_ioctl = mmtimer_ioctl,
.owner = THIS_MODULE,
.mmap = mmtimer_mmap,
.unlocked_ioctl = mmtimer_ioctl,
static const struct file_operations fetchop_fops = {
.owner = THIS_MODULE,
static const struct file_operations fetchop_fops = {
.owner = THIS_MODULE,
+ .mmap = fetchop_mmap,
+ .llseek = noop_llseek,
};
static struct miscdevice fetchop_miscdev = {
};
static struct miscdevice fetchop_miscdev = {
static const struct file_operations cached_fops = {
.owner = THIS_MODULE,
static const struct file_operations cached_fops = {
.owner = THIS_MODULE,
+ .mmap = cached_mmap,
+ .llseek = noop_llseek,
};
static struct miscdevice cached_miscdev = {
};
static struct miscdevice cached_miscdev = {
static const struct file_operations uncached_fops = {
.owner = THIS_MODULE,
static const struct file_operations uncached_fops = {
.owner = THIS_MODULE,
+ .mmap = uncached_mmap,
+ .llseek = noop_llseek,
};
static struct miscdevice uncached_miscdev = {
};
static struct miscdevice uncached_miscdev = {
.write = mwave_write,
.unlocked_ioctl = mwave_ioctl,
.open = mwave_open,
.write = mwave_write,
.unlocked_ioctl = mwave_ioctl,
.open = mwave_open,
+ .release = mwave_close,
+ .llseek = default_llseek,
static const struct file_operations button_fops = {
.owner = THIS_MODULE,
.read = button_read,
static const struct file_operations button_fops = {
.owner = THIS_MODULE,
.read = button_read,
.open = pc8736x_gpio_open,
.write = nsc_gpio_write,
.read = nsc_gpio_read,
.open = pc8736x_gpio_open,
.write = nsc_gpio_write,
.read = nsc_gpio_read,
};
static void __init pc8736x_init_shadow(void)
};
static void __init pc8736x_init_shadow(void)
.unlocked_ioctl = cmm_ioctl,
.open = cmm_open,
.release= cmm_close,
.unlocked_ioctl = cmm_ioctl,
.open = cmm_open,
.release= cmm_close,
};
static struct pcmcia_device_id cm4000_ids[] = {
};
static struct pcmcia_device_id cm4000_ids[] = {
.open = cm4040_open,
.release = cm4040_close,
.poll = cm4040_poll,
.open = cm4040_open,
.release = cm4040_close,
.poll = cm4040_poll,
};
static struct pcmcia_device_id cm4040_ids[] = {
};
static struct pcmcia_device_id cm4040_ids[] = {
.poll = random_poll,
.unlocked_ioctl = random_ioctl,
.fasync = random_fasync,
.poll = random_poll,
.unlocked_ioctl = random_ioctl,
.fasync = random_fasync,
};
const struct file_operations urandom_fops = {
};
const struct file_operations urandom_fops = {
.write = random_write,
.unlocked_ioctl = random_ioctl,
.fasync = random_fasync,
.write = random_write,
.unlocked_ioctl = random_ioctl,
.fasync = random_fasync,
};
/***************************************************************
};
/***************************************************************
static const struct file_operations rio_fw_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = rio_fw_ioctl,
static const struct file_operations rio_fw_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = rio_fw_ioctl,
};
static struct miscdevice rio_fw_device = {
};
static struct miscdevice rio_fw_device = {
.read = nsc_gpio_read,
.open = scx200_gpio_open,
.release = scx200_gpio_release,
.read = nsc_gpio_read,
.open = scx200_gpio_open,
.release = scx200_gpio_release,
};
static struct cdev scx200_gpio_cdev; /* use 1 cdev for all pins */
};
static struct cdev scx200_gpio_cdev; /* use 1 cdev for all pins */
.poll = scdrv_poll,
.open = scdrv_open,
.release = scdrv_release,
.poll = scdrv_poll,
.open = scdrv_open,
.release = scdrv_release,
};
static struct class *snsc_class;
};
static struct class *snsc_class;
static const struct file_operations stl_fsiomem = {
.owner = THIS_MODULE,
.unlocked_ioctl = stl_memioctl,
static const struct file_operations stl_fsiomem = {
.owner = THIS_MODULE,
.unlocked_ioctl = stl_memioctl,
};
static struct class *stallion_class;
};
static struct class *stallion_class;
static const struct file_operations sx_fw_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = sx_fw_ioctl,
static const struct file_operations sx_fw_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = sx_fw_ioctl,
};
static struct miscdevice sx_fw_device = {
};
static struct miscdevice sx_fw_device = {
static const struct file_operations proc_sysrq_trigger_operations = {
.write = write_sysrq_trigger,
static const struct file_operations proc_sysrq_trigger_operations = {
.write = write_sysrq_trigger,
};
static void sysrq_init_procfs(void)
};
static void sysrq_init_procfs(void)
.write = tanbac_tb0219_write,
.open = tanbac_tb0219_open,
.release = tanbac_tb0219_release,
.write = tanbac_tb0219_write,
.open = tanbac_tb0219_open,
.release = tanbac_tb0219_release,
};
static void tb0219_restart(char *command)
};
static void tb0219_restart(char *command)
.read = tlclk_read,
.open = tlclk_open,
.release = tlclk_release,
.read = tlclk_read,
.open = tlclk_open,
.release = tlclk_release,
static const struct file_operations tosh_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = tosh_ioctl,
static const struct file_operations tosh_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = tosh_ioctl,
};
static struct miscdevice tosh_device = {
};
static struct miscdevice tosh_device = {
.owner = THIS_MODULE,
.mmap = uv_mmtimer_mmap,
.unlocked_ioctl = uv_mmtimer_ioctl,
.owner = THIS_MODULE,
.mmap = uv_mmtimer_mmap,
.unlocked_ioctl = uv_mmtimer_ioctl,
.read = hwicap_read,
.open = hwicap_open,
.release = hwicap_release,
.read = hwicap_read,
.open = hwicap_open,
.release = hwicap_release,
};
static int __devinit hwicap_setup(struct device *dev, int id,
};
static int __devinit hwicap_setup(struct device *dev, int id,
.owner = THIS_MODULE,
.open = coh901318_debugfs_open,
.read = coh901318_debugfs_read,
.owner = THIS_MODULE,
.open = coh901318_debugfs_open,
.read = coh901318_debugfs_read,
+ .llseek = default_llseek,
.poll = nosy_poll,
.open = nosy_open,
.release = nosy_release,
.poll = nosy_poll,
.open = nosy_open,
.release = nosy_release,
};
#define PHY_PACKET_SIZE 12 /* 1 payload, 1 inverse, 1 ack = 3 quadlets */
};
#define PHY_PACKET_SIZE 12 /* 1 payload, 1 inverse, 1 ack = 3 quadlets */
/** File operations structure */
static const struct file_operations drm_stub_fops = {
.owner = THIS_MODULE,
/** File operations structure */
static const struct file_operations drm_stub_fops = {
.owner = THIS_MODULE,
+ .open = drm_stub_open,
+ .llseek = noop_llseek,
};
static int __init drm_core_init(void)
};
static int __init drm_core_init(void)
.unlocked_ioctl = drm_ioctl,
.mmap = i810_mmap_buffers,
.fasync = drm_fasync,
.unlocked_ioctl = drm_ioctl,
.mmap = i810_mmap_buffers,
.fasync = drm_fasync,
};
static int i810_map_buffer(struct drm_buf *buf, struct drm_file *file_priv)
};
static int i810_map_buffer(struct drm_buf *buf, struct drm_file *file_priv)
.unlocked_ioctl = drm_ioctl,
.mmap = i830_mmap_buffers,
.fasync = drm_fasync,
.unlocked_ioctl = drm_ioctl,
.mmap = i830_mmap_buffers,
.fasync = drm_fasync,
};
static int i830_map_buffer(struct drm_buf *buf, struct drm_file *file_priv)
};
static int i830_map_buffer(struct drm_buf *buf, struct drm_file *file_priv)
.open = i915_wedged_open,
.read = i915_wedged_read,
.write = i915_wedged_write,
.open = i915_wedged_open,
.read = i915_wedged_read,
.write = i915_wedged_write,
+ .llseek = default_llseek,
};
/* As the drm_debugfs_init() routines are called before dev->dev_private is
};
/* As the drm_debugfs_init() routines are called before dev->dev_private is
.poll = vga_arb_fpoll,
.open = vga_arb_open,
.release = vga_arb_release,
.poll = vga_arb_fpoll,
.open = vga_arb_open,
.release = vga_arb_release,
};
static struct miscdevice vga_arb_device = {
};
static struct miscdevice vga_arb_device = {
.read = hid_debug_events_read,
.poll = hid_debug_events_poll,
.release = hid_debug_events_release,
.read = hid_debug_events_read,
.poll = hid_debug_events_poll,
.release = hid_debug_events_release,
.poll = roccat_poll,
.open = roccat_open,
.release = roccat_release,
.poll = roccat_poll,
.open = roccat_open,
.release = roccat_release,
};
static int __init roccat_init(void)
};
static int __init roccat_init(void)
.open = hidraw_open,
.release = hidraw_release,
.unlocked_ioctl = hidraw_ioctl,
.open = hidraw_open,
.release = hidraw_release,
.unlocked_ioctl = hidraw_ioctl,
};
void hidraw_report_event(struct hid_device *hid, u8 *data, int len)
};
void hidraw_report_event(struct hid_device *hid, u8 *data, int len)
#ifdef CONFIG_COMPAT
.compat_ioctl = hiddev_compat_ioctl,
#endif
#ifdef CONFIG_COMPAT
.compat_ioctl = hiddev_compat_ioctl,
#endif
};
static char *hiddev_devnode(struct device *dev, mode_t *mode)
};
static char *hiddev_devnode(struct device *dev, mode_t *mode)
.read = atk_debugfs_ggrp_read,
.open = atk_debugfs_ggrp_open,
.release = atk_debugfs_ggrp_release,
.read = atk_debugfs_ggrp_read,
.open = atk_debugfs_ggrp_open,
.release = atk_debugfs_ggrp_release,
};
static void atk_debugfs_init(struct atk_data *data)
};
static void atk_debugfs_init(struct atk_data *data)
.unlocked_ioctl = idetape_chrdev_ioctl,
.open = idetape_chrdev_open,
.release = idetape_chrdev_release,
.unlocked_ioctl = idetape_chrdev_ioctl,
.open = idetape_chrdev_open,
.release = idetape_chrdev_release,
};
static int idetape_open(struct block_device *bdev, fmode_t mode)
};
static int idetape_open(struct block_device *bdev, fmode_t mode)
static const struct file_operations idle_fops = {
.open = stats_open_generic,
.read = stats_read_ul,
static const struct file_operations idle_fops = {
.open = stats_open_generic,
.read = stats_read_ul,
+ .llseek = default_llseek,
};
struct debugfs_file_info {
};
struct debugfs_file_info {
.write = ipath_diag_write,
.read = ipath_diag_read,
.open = ipath_diag_open,
.write = ipath_diag_write,
.read = ipath_diag_read,
.open = ipath_diag_open,
- .release = ipath_diag_release
+ .release = ipath_diag_release,
+ .llseek = default_llseek,
};
static ssize_t ipath_diagpkt_write(struct file *fp,
};
static ssize_t ipath_diagpkt_write(struct file *fp,
static const struct file_operations diagpkt_file_ops = {
.owner = THIS_MODULE,
.write = ipath_diagpkt_write,
static const struct file_operations diagpkt_file_ops = {
.owner = THIS_MODULE,
.write = ipath_diagpkt_write,
};
static atomic_t diagpkt_count = ATOMIC_INIT(0);
};
static atomic_t diagpkt_count = ATOMIC_INIT(0);
.open = ipath_open,
.release = ipath_close,
.poll = ipath_poll,
.open = ipath_open,
.release = ipath_close,
.poll = ipath_poll,
+ .mmap = ipath_mmap,
+ .llseek = noop_llseek,
static const struct file_operations atomic_stats_ops = {
.read = atomic_stats_read,
static const struct file_operations atomic_stats_ops = {
.read = atomic_stats_read,
+ .llseek = default_llseek,
};
static ssize_t atomic_counters_read(struct file *file, char __user *buf,
};
static ssize_t atomic_counters_read(struct file *file, char __user *buf,
static const struct file_operations atomic_counters_ops = {
.read = atomic_counters_read,
static const struct file_operations atomic_counters_ops = {
.read = atomic_counters_read,
+ .llseek = default_llseek,
};
static ssize_t flash_read(struct file *file, char __user *buf,
};
static ssize_t flash_read(struct file *file, char __user *buf,
static const struct file_operations flash_ops = {
.read = flash_read,
.write = flash_write,
static const struct file_operations flash_ops = {
.read = flash_read,
.write = flash_write,
+ .llseek = default_llseek,
};
static int create_device_files(struct super_block *sb,
};
static int create_device_files(struct super_block *sb,
.write = qib_diag_write,
.read = qib_diag_read,
.open = qib_diag_open,
.write = qib_diag_write,
.read = qib_diag_read,
.open = qib_diag_open,
- .release = qib_diag_release
+ .release = qib_diag_release,
+ .llseek = default_llseek,
};
static atomic_t diagpkt_count = ATOMIC_INIT(0);
};
static atomic_t diagpkt_count = ATOMIC_INIT(0);
static const struct file_operations diagpkt_file_ops = {
.owner = THIS_MODULE,
.write = qib_diagpkt_write,
static const struct file_operations diagpkt_file_ops = {
.owner = THIS_MODULE,
.write = qib_diagpkt_write,
};
int qib_diag_add(struct qib_devdata *dd)
};
int qib_diag_add(struct qib_devdata *dd)
.open = qib_open,
.release = qib_close,
.poll = qib_poll,
.open = qib_open,
.release = qib_close,
.poll = qib_poll,
+ .mmap = qib_mmapf,
+ .llseek = noop_llseek,
static const struct file_operations flash_ops = {
.read = flash_read,
.write = flash_write,
static const struct file_operations flash_ops = {
.read = flash_read,
.write = flash_write,
+ .llseek = default_llseek,
};
static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
};
static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
.compat_ioctl = evdev_ioctl_compat,
#endif
.fasync = evdev_fasync,
.compat_ioctl = evdev_ioctl_compat,
#endif
.fasync = evdev_fasync,
+ .flush = evdev_flush,
+ .llseek = no_llseek,
};
static int evdev_install_chrdev(struct evdev *evdev)
};
static int evdev_install_chrdev(struct evdev *evdev)
static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
};
static int __init input_init(void)
};
static int __init input_init(void)
.compat_ioctl = joydev_compat_ioctl,
#endif
.fasync = joydev_fasync,
.compat_ioctl = joydev_compat_ioctl,
#endif
.fasync = joydev_fasync,
};
static int joydev_install_chrdev(struct joydev *joydev)
};
static int joydev_install_chrdev(struct joydev *joydev)
#ifdef CONFIG_COMPAT
.compat_ioctl = uinput_compat_ioctl,
#endif
#ifdef CONFIG_COMPAT
.compat_ioctl = uinput_compat_ioctl,
#endif
};
static struct miscdevice uinput_misc = {
};
static struct miscdevice uinput_misc = {
.open = mousedev_open,
.release = mousedev_release,
.fasync = mousedev_fasync,
.open = mousedev_open,
.release = mousedev_release,
.fasync = mousedev_fasync,
};
static int mousedev_install_chrdev(struct mousedev *mousedev)
};
static int mousedev_install_chrdev(struct mousedev *mousedev)
.write = serio_raw_write,
.poll = serio_raw_poll,
.fasync = serio_raw_fasync,
.write = serio_raw_write,
.poll = serio_raw_poll,
.fasync = serio_raw_fasync,
.unlocked_ioctl = mISDN_ioctl,
.open = mISDN_open,
.release = mISDN_close,
.unlocked_ioctl = mISDN_ioctl,
.open = mISDN_open,
.release = mISDN_close,
};
static struct miscdevice mISDNtimer = {
};
static struct miscdevice mISDNtimer = {
.release = close,
.write = write,
.read = read,
.release = close,
.write = write,
.read = read,
+ .llseek = default_llseek,
.write = anslcd_write,
.unlocked_ioctl = anslcd_ioctl,
.open = anslcd_open,
.write = anslcd_write,
.unlocked_ioctl = anslcd_ioctl,
.open = anslcd_open,
+ .llseek = default_llseek,
};
static struct miscdevice anslcd_dev = {
};
static struct miscdevice anslcd_dev = {
#endif
.open = pmu_open,
.release = pmu_release,
#endif
.open = pmu_open,
.release = pmu_release,
};
static struct miscdevice pmu_device = {
};
static struct miscdevice pmu_device = {
.unlocked_ioctl = dm_ctl_ioctl,
.compat_ioctl = dm_compat_ctl_ioctl,
.owner = THIS_MODULE,
.unlocked_ioctl = dm_ctl_ioctl,
.compat_ioctl = dm_compat_ctl_ioctl,
.owner = THIS_MODULE,
};
static struct miscdevice _dm_misc = {
};
static struct miscdevice _dm_misc = {
.owner = THIS_MODULE,
.open = &display_open,
.write = &vfd_write,
.owner = THIS_MODULE,
.open = &display_open,
.write = &vfd_write,
- .release = &display_close
+ .release = &display_close,
+ .llseek = noop_llseek,
};
/* lcd character device file operations */
};
/* lcd character device file operations */
.owner = THIS_MODULE,
.open = &display_open,
.write = &lcd_write,
.owner = THIS_MODULE,
.open = &display_open,
.write = &lcd_write,
- .release = &display_close
+ .release = &display_close,
+ .llseek = noop_llseek,
.unlocked_ioctl = lirc_dev_fop_ioctl,
.open = lirc_dev_fop_open,
.release = lirc_dev_fop_close,
.unlocked_ioctl = lirc_dev_fop_ioctl,
.open = lirc_dev_fop_open,
.release = lirc_dev_fop_close,
};
static int lirc_cdev_add(struct irctl *ir)
};
static int lirc_cdev_add(struct irctl *ir)
.open = dst_ca_open,
.release = dst_ca_release,
.read = dst_ca_read,
.open = dst_ca_open,
.release = dst_ca_release,
.read = dst_ca_read,
+ .write = dst_ca_write,
+ .llseek = noop_llseek,
};
static struct dvb_device dvbdev_ca = {
};
static struct dvb_device dvbdev_ca = {
.open = dvb_demux_open,
.release = dvb_demux_release,
.poll = dvb_demux_poll,
.open = dvb_demux_open,
.release = dvb_demux_release,
.poll = dvb_demux_poll,
+ .llseek = default_llseek,
};
static struct dvb_device dvbdev_demux = {
};
static struct dvb_device dvbdev_demux = {
.open = dvb_dvr_open,
.release = dvb_dvr_release,
.poll = dvb_dvr_poll,
.open = dvb_dvr_open,
.release = dvb_dvr_release,
.poll = dvb_dvr_poll,
+ .llseek = default_llseek,
};
static struct dvb_device dvbdev_dvr = {
};
static struct dvb_device dvbdev_dvr = {
.open = dvb_ca_en50221_io_open,
.release = dvb_ca_en50221_io_release,
.poll = dvb_ca_en50221_io_poll,
.open = dvb_ca_en50221_io_open,
.release = dvb_ca_en50221_io_release,
.poll = dvb_ca_en50221_io_poll,
};
static struct dvb_device dvbdev_ca = {
};
static struct dvb_device dvbdev_ca = {
.unlocked_ioctl = dvb_generic_ioctl,
.poll = dvb_frontend_poll,
.open = dvb_frontend_open,
.unlocked_ioctl = dvb_generic_ioctl,
.poll = dvb_frontend_poll,
.open = dvb_frontend_open,
- .release = dvb_frontend_release
+ .release = dvb_frontend_release,
+ .llseek = noop_llseek,
};
int dvb_register_frontend(struct dvb_adapter* dvb,
};
int dvb_register_frontend(struct dvb_adapter* dvb,
.unlocked_ioctl = dvb_net_ioctl,
.open = dvb_generic_open,
.release = dvb_net_close,
.unlocked_ioctl = dvb_net_ioctl,
.open = dvb_generic_open,
.release = dvb_net_close,
};
static struct dvb_device dvbdev_net = {
};
static struct dvb_device dvbdev_net = {
{
.owner = THIS_MODULE,
.open = dvb_device_open,
{
.owner = THIS_MODULE,
.open = dvb_device_open,
};
static struct cdev dvb_device_cdev;
};
static struct cdev dvb_device_cdev;
.open = dvb_generic_open,
.release = dvb_generic_release,
.poll = fdtv_ca_io_poll,
.open = dvb_generic_open,
.release = dvb_generic_release,
.poll = fdtv_ca_io_poll,
};
static struct dvb_device fdtv_ca = {
};
static struct dvb_device fdtv_ca = {
.unlocked_ioctl = dvb_generic_ioctl,
.open = dvb_generic_open,
.release = dvb_generic_release,
.unlocked_ioctl = dvb_generic_ioctl,
.open = dvb_generic_open,
.release = dvb_generic_release,
};
static struct dvb_device dvbdev_osd = {
};
static struct dvb_device dvbdev_osd = {
.open = dvb_video_open,
.release = dvb_video_release,
.poll = dvb_video_poll,
.open = dvb_video_open,
.release = dvb_video_release,
.poll = dvb_video_poll,
};
static struct dvb_device dvbdev_video = {
};
static struct dvb_device dvbdev_video = {
.open = dvb_audio_open,
.release = dvb_audio_release,
.poll = dvb_audio_poll,
.open = dvb_audio_open,
.release = dvb_audio_release,
.poll = dvb_audio_poll,
};
static struct dvb_device dvbdev_audio = {
};
static struct dvb_device dvbdev_audio = {
.open = dvb_ca_open,
.release = dvb_generic_release,
.poll = dvb_ca_poll,
.open = dvb_ca_open,
.release = dvb_generic_release,
.poll = dvb_ca_poll,
+ .llseek = default_llseek,
};
static struct dvb_device dvbdev_ca = {
};
static struct dvb_device dvbdev_ca = {
static const struct file_operations av7110_ir_proc_fops = {
.owner = THIS_MODULE,
.write = av7110_ir_proc_write,
static const struct file_operations av7110_ir_proc_fops = {
.owner = THIS_MODULE,
.write = av7110_ir_proc_write,
};
/* interrupt handler */
};
/* interrupt handler */
static const struct file_operations ab3100_get_set_reg_fops = {
.open = ab3100_get_set_reg_open_file,
.write = ab3100_get_set_reg,
static const struct file_operations ab3100_get_set_reg_fops = {
.open = ab3100_get_set_reg_open_file,
.write = ab3100_get_set_reg,
};
static struct dentry *ab3100_dir;
};
static struct dentry *ab3100_dir;
.poll = ilo_poll,
.open = ilo_open,
.release = ilo_close,
.poll = ilo_poll,
.open = ilo_open,
.release = ilo_close,
};
static irqreturn_t ilo_isr(int irq, void *data)
};
static irqreturn_t ilo_isr(int irq, void *data)
.unlocked_ioctl = phantom_ioctl,
.compat_ioctl = phantom_compat_ioctl,
.poll = phantom_poll,
.unlocked_ioctl = phantom_ioctl,
.compat_ioctl = phantom_compat_ioctl,
.poll = phantom_poll,
};
static irqreturn_t phantom_isr(int irq, void *data)
};
static irqreturn_t phantom_isr(int irq, void *data)
.owner = THIS_MODULE,
.unlocked_ioctl = gru_file_unlocked_ioctl,
.mmap = gru_file_mmap,
.owner = THIS_MODULE,
.unlocked_ioctl = gru_file_unlocked_ioctl,
.mmap = gru_file_mmap,
};
static struct miscdevice gru_miscdev = {
};
static struct miscdevice gru_miscdev = {
.open = mmc_ext_csd_open,
.read = mmc_ext_csd_read,
.release = mmc_ext_csd_release,
.open = mmc_ext_csd_open,
.read = mmc_ext_csd_read,
.release = mmc_ext_csd_release,
+ .llseek = default_llseek,
};
void mmc_add_card_debugfs(struct mmc_card *card)
};
void mmc_add_card_debugfs(struct mmc_card *card)
.owner = THIS_MODULE,
.unlocked_ioctl = ctrl_cdev_ioctl,
.compat_ioctl = ctrl_cdev_compat_ioctl,
.owner = THIS_MODULE,
.unlocked_ioctl = ctrl_cdev_ioctl,
.compat_ioctl = ctrl_cdev_compat_ioctl,
static const struct file_operations dbgfs_state_fops = {
.open = dbgfs_open,
.read = dbgfs_state,
static const struct file_operations dbgfs_state_fops = {
.open = dbgfs_open,
.read = dbgfs_state,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
static const struct file_operations dbgfs_frame_fops = {
.open = dbgfs_open,
.read = dbgfs_frame,
};
static const struct file_operations dbgfs_frame_fops = {
.open = dbgfs_open,
.read = dbgfs_frame,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
static inline void dev_debugfs_add(struct cfspi *cfspi)
};
static inline void dev_debugfs_add(struct cfspi *cfspi)
.owner = THIS_MODULE,
.open = mem_open,
.read = mem_read,
.owner = THIS_MODULE,
.open = mem_open,
.read = mem_read,
+ .llseek = default_llseek,
};
static void __devinit add_debugfs_mem(struct adapter *adap, const char *name,
};
static void __devinit add_debugfs_mem(struct adapter *adap, const char *name,
.poll = ppp_poll,
.unlocked_ioctl = ppp_ioctl,
.open = ppp_open,
.poll = ppp_poll,
.unlocked_ioctl = ppp_ioctl,
.open = ppp_open,
+ .release = ppp_release,
+ .llseek = noop_llseek,
};
static __net_init int ppp_init_net(struct net *net)
};
static __net_init int ppp_init_net(struct net *net)
.open = i2400m_stats_open,
.read = i2400m_rx_stats_read,
.write = i2400m_rx_stats_write,
.open = i2400m_stats_open,
.read = i2400m_rx_stats_read,
.write = i2400m_rx_stats_write,
+ .llseek = default_llseek,
.open = i2400m_stats_open,
.read = i2400m_tx_stats_read,
.write = i2400m_tx_stats_write,
.open = i2400m_stats_open,
.read = i2400m_tx_stats_read,
.write = i2400m_tx_stats_write,
+ .llseek = default_llseek,
.owner = THIS_MODULE,
.read = proc_read,
.open = proc_statsdelta_open,
.owner = THIS_MODULE,
.read = proc_read,
.open = proc_statsdelta_open,
+ .release = proc_close,
+ .llseek = default_llseek,
};
static const struct file_operations proc_stats_ops = {
.owner = THIS_MODULE,
.read = proc_read,
.open = proc_stats_open,
};
static const struct file_operations proc_stats_ops = {
.owner = THIS_MODULE,
.read = proc_read,
.open = proc_stats_open,
+ .release = proc_close,
+ .llseek = default_llseek,
};
static const struct file_operations proc_status_ops = {
.owner = THIS_MODULE,
.read = proc_read,
.open = proc_status_open,
};
static const struct file_operations proc_status_ops = {
.owner = THIS_MODULE,
.read = proc_read,
.open = proc_status_open,
+ .release = proc_close,
+ .llseek = default_llseek,
};
static const struct file_operations proc_SSID_ops = {
};
static const struct file_operations proc_SSID_ops = {
.read = proc_read,
.write = proc_write,
.open = proc_SSID_open,
.read = proc_read,
.write = proc_write,
.open = proc_SSID_open,
+ .release = proc_close,
+ .llseek = default_llseek,
};
static const struct file_operations proc_BSSList_ops = {
};
static const struct file_operations proc_BSSList_ops = {
.read = proc_read,
.write = proc_write,
.open = proc_BSSList_open,
.read = proc_read,
.write = proc_write,
.open = proc_BSSList_open,
+ .release = proc_close,
+ .llseek = default_llseek,
};
static const struct file_operations proc_APList_ops = {
};
static const struct file_operations proc_APList_ops = {
.read = proc_read,
.write = proc_write,
.open = proc_APList_open,
.read = proc_read,
.write = proc_write,
.open = proc_APList_open,
+ .release = proc_close,
+ .llseek = default_llseek,
};
static const struct file_operations proc_config_ops = {
};
static const struct file_operations proc_config_ops = {
.read = proc_read,
.write = proc_write,
.open = proc_config_open,
.read = proc_read,
.write = proc_write,
.open = proc_config_open,
+ .release = proc_close,
+ .llseek = default_llseek,
};
static const struct file_operations proc_wepkey_ops = {
};
static const struct file_operations proc_wepkey_ops = {
.read = proc_read,
.write = proc_write,
.open = proc_wepkey_open,
.read = proc_read,
.write = proc_write,
.open = proc_wepkey_open,
+ .release = proc_close,
+ .llseek = default_llseek,
};
static struct proc_dir_entry *airo_entry;
};
static struct proc_dir_entry *airo_entry;
.write = write_file_beacon,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
.write = write_file_beacon,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
+ .llseek = default_llseek,
.write = write_file_reset,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
.write = write_file_reset,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
.write = write_file_debug,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
.write = write_file_debug,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
+ .llseek = default_llseek,
.write = write_file_antenna,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
.write = write_file_antenna,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
+ .llseek = default_llseek,
.write = write_file_frameerrors,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
.write = write_file_frameerrors,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
+ .llseek = default_llseek,
.write = write_file_ani,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
.write = write_file_ani,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
+ .llseek = default_llseek,
.write = write_file_queue,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
.write = write_file_queue,
.open = ath5k_debugfs_open,
.owner = THIS_MODULE,
+ .llseek = default_llseek,
.read = read_file_debug,
.write = write_file_debug,
.open = ath9k_debugfs_open,
.read = read_file_debug,
.write = write_file_debug,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
.read = read_file_tx_chainmask,
.write = write_file_tx_chainmask,
.open = ath9k_debugfs_open,
.read = read_file_tx_chainmask,
.write = write_file_tx_chainmask,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
.read = read_file_rx_chainmask,
.write = write_file_rx_chainmask,
.open = ath9k_debugfs_open,
.read = read_file_rx_chainmask,
.write = write_file_rx_chainmask,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
static const struct file_operations fops_dma = {
.read = read_file_dma,
.open = ath9k_debugfs_open,
static const struct file_operations fops_dma = {
.read = read_file_dma,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
static const struct file_operations fops_interrupt = {
.read = read_file_interrupt,
.open = ath9k_debugfs_open,
static const struct file_operations fops_interrupt = {
.read = read_file_interrupt,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
void ath_debug_stat_rc(struct ath_softc *sc, int final_rate)
};
void ath_debug_stat_rc(struct ath_softc *sc, int final_rate)
static const struct file_operations fops_rcstat = {
.read = read_file_rcstat,
.open = ath9k_debugfs_open,
static const struct file_operations fops_rcstat = {
.read = read_file_rcstat,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
static const char * ath_wiphy_state_str(enum ath_wiphy_state state)
};
static const char * ath_wiphy_state_str(enum ath_wiphy_state state)
.read = read_file_wiphy,
.write = write_file_wiphy,
.open = ath9k_debugfs_open,
.read = read_file_wiphy,
.write = write_file_wiphy,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
#define PR(str, elem) \
};
#define PR(str, elem) \
static const struct file_operations fops_xmit = {
.read = read_file_xmit,
.open = ath9k_debugfs_open,
static const struct file_operations fops_xmit = {
.read = read_file_xmit,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
static ssize_t read_file_recv(struct file *file, char __user *user_buf,
};
static ssize_t read_file_recv(struct file *file, char __user *user_buf,
static const struct file_operations fops_recv = {
.read = read_file_recv,
.open = ath9k_debugfs_open,
static const struct file_operations fops_recv = {
.read = read_file_recv,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
static ssize_t read_file_regidx(struct file *file, char __user *user_buf,
};
static ssize_t read_file_regidx(struct file *file, char __user *user_buf,
.read = read_file_regidx,
.write = write_file_regidx,
.open = ath9k_debugfs_open,
.read = read_file_regidx,
.write = write_file_regidx,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
static ssize_t read_file_regval(struct file *file, char __user *user_buf,
};
static ssize_t read_file_regval(struct file *file, char __user *user_buf,
.read = read_file_regval,
.write = write_file_regval,
.open = ath9k_debugfs_open,
.read = read_file_regval,
.write = write_file_regval,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
int ath9k_init_debug(struct ath_hw *ah)
};
int ath9k_init_debug(struct ath_hw *ah)
static const struct file_operations fops_tgt_stats = {
.read = read_file_tgt_stats,
.open = ath9k_debugfs_open,
static const struct file_operations fops_tgt_stats = {
.read = read_file_tgt_stats,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
static ssize_t read_file_xmit(struct file *file, char __user *user_buf,
};
static ssize_t read_file_xmit(struct file *file, char __user *user_buf,
static const struct file_operations fops_xmit = {
.read = read_file_xmit,
.open = ath9k_debugfs_open,
static const struct file_operations fops_xmit = {
.read = read_file_xmit,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
static ssize_t read_file_recv(struct file *file, char __user *user_buf,
};
static ssize_t read_file_recv(struct file *file, char __user *user_buf,
static const struct file_operations fops_recv = {
.read = read_file_recv,
.open = ath9k_debugfs_open,
static const struct file_operations fops_recv = {
.read = read_file_recv,
.open = ath9k_debugfs_open,
+ .owner = THIS_MODULE,
+ .llseek = default_llseek,
};
int ath9k_htc_init_debug(struct ath_hw *ah)
};
int ath9k_htc_init_debug(struct ath_hw *ah)
static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
.read = iwl3945_sta_dbgfs_stats_table_read,
.open = iwl3945_open_file_generic,
static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
.read = iwl3945_sta_dbgfs_stats_table_read,
.open = iwl3945_open_file_generic,
+ .llseek = default_llseek,
};
static void iwl3945_add_debugfs(void *priv, void *priv_sta,
};
static void iwl3945_add_debugfs(void *priv, void *priv_sta,
.write = rs_sta_dbgfs_scale_table_write,
.read = rs_sta_dbgfs_scale_table_read,
.open = open_file_generic,
.write = rs_sta_dbgfs_scale_table_write,
.read = rs_sta_dbgfs_scale_table_read,
.open = open_file_generic,
+ .llseek = default_llseek,
};
static ssize_t rs_sta_dbgfs_stats_table_read(struct file *file,
char __user *user_buf, size_t count, loff_t *ppos)
};
static ssize_t rs_sta_dbgfs_stats_table_read(struct file *file,
char __user *user_buf, size_t count, loff_t *ppos)
static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
.read = rs_sta_dbgfs_stats_table_read,
.open = open_file_generic,
static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
.read = rs_sta_dbgfs_stats_table_read,
.open = open_file_generic,
+ .llseek = default_llseek,
};
static ssize_t rs_sta_dbgfs_rate_scale_data_read(struct file *file,
};
static ssize_t rs_sta_dbgfs_rate_scale_data_read(struct file *file,
static const struct file_operations rs_sta_dbgfs_rate_scale_data_ops = {
.read = rs_sta_dbgfs_rate_scale_data_read,
.open = open_file_generic,
static const struct file_operations rs_sta_dbgfs_rate_scale_data_ops = {
.read = rs_sta_dbgfs_rate_scale_data_read,
.open = open_file_generic,
+ .llseek = default_llseek,
};
static void rs_add_debugfs(void *priv, void *priv_sta,
};
static void rs_add_debugfs(void *priv, void *priv_sta,
.owner = THIS_MODULE,
.open = iwm_generic_open,
.read = iwm_debugfs_txq_read,
.owner = THIS_MODULE,
.open = iwm_generic_open,
.read = iwm_debugfs_txq_read,
+ .llseek = default_llseek,
};
static const struct file_operations iwm_debugfs_tx_credit_fops = {
.owner = THIS_MODULE,
.open = iwm_generic_open,
.read = iwm_debugfs_tx_credit_read,
};
static const struct file_operations iwm_debugfs_tx_credit_fops = {
.owner = THIS_MODULE,
.open = iwm_generic_open,
.read = iwm_debugfs_tx_credit_read,
+ .llseek = default_llseek,
};
static const struct file_operations iwm_debugfs_rx_ticket_fops = {
.owner = THIS_MODULE,
.open = iwm_generic_open,
.read = iwm_debugfs_rx_ticket_read,
};
static const struct file_operations iwm_debugfs_rx_ticket_fops = {
.owner = THIS_MODULE,
.open = iwm_generic_open,
.read = iwm_debugfs_rx_ticket_read,
+ .llseek = default_llseek,
};
static const struct file_operations iwm_debugfs_fw_err_fops = {
.owner = THIS_MODULE,
.open = iwm_generic_open,
.read = iwm_debugfs_fw_err_read,
};
static const struct file_operations iwm_debugfs_fw_err_fops = {
.owner = THIS_MODULE,
.open = iwm_generic_open,
.read = iwm_debugfs_fw_err_read,
+ .llseek = default_llseek,
};
void iwm_debugfs_init(struct iwm_priv *iwm)
};
void iwm_debugfs_init(struct iwm_priv *iwm)
.owner = THIS_MODULE,
.open = iwm_debugfs_sdio_open,
.read = iwm_debugfs_sdio_read,
.owner = THIS_MODULE,
.open = iwm_debugfs_sdio_open,
.read = iwm_debugfs_sdio_read,
+ .llseek = default_llseek,
};
static void if_sdio_debugfs_init(struct iwm_priv *iwm, struct dentry *parent_dir)
};
static void if_sdio_debugfs_init(struct iwm_priv *iwm, struct dentry *parent_dir)
.open = open_file_generic,
.write = lbs_debugfs_write,
.read = lbs_debugfs_read,
.open = open_file_generic,
.write = lbs_debugfs_write,
.read = lbs_debugfs_read,
+ .llseek = default_llseek,
static const struct file_operations ray_cs_essid_proc_fops = {
.owner = THIS_MODULE,
.write = ray_cs_essid_proc_write,
static const struct file_operations ray_cs_essid_proc_fops = {
.owner = THIS_MODULE,
.write = ray_cs_essid_proc_write,
};
static ssize_t int_proc_write(struct file *file, const char __user *buffer,
};
static ssize_t int_proc_write(struct file *file, const char __user *buffer,
static const struct file_operations int_proc_fops = {
.owner = THIS_MODULE,
.write = int_proc_write,
static const struct file_operations int_proc_fops = {
.owner = THIS_MODULE,
.write = int_proc_write,
.poll = rt2x00debug_poll_queue_dump,
.open = rt2x00debug_open_queue_dump,
.release = rt2x00debug_release_queue_dump,
.poll = rt2x00debug_poll_queue_dump,
.open = rt2x00debug_open_queue_dump,
.release = rt2x00debug_release_queue_dump,
+ .llseek = default_llseek,
};
static ssize_t rt2x00debug_read_queue_stats(struct file *file,
};
static ssize_t rt2x00debug_read_queue_stats(struct file *file,
.read = rt2x00debug_read_queue_stats,
.open = rt2x00debug_file_open,
.release = rt2x00debug_file_release,
.read = rt2x00debug_read_queue_stats,
.open = rt2x00debug_file_open,
.release = rt2x00debug_file_release,
+ .llseek = default_llseek,
};
#ifdef CONFIG_RT2X00_LIB_CRYPTO
};
#ifdef CONFIG_RT2X00_LIB_CRYPTO
.read = rt2x00debug_read_crypto_stats,
.open = rt2x00debug_file_open,
.release = rt2x00debug_file_release,
.read = rt2x00debug_read_crypto_stats,
.open = rt2x00debug_file_open,
.release = rt2x00debug_file_release,
+ .llseek = default_llseek,
.read = rt2x00debug_read_dev_flags,
.open = rt2x00debug_file_open,
.release = rt2x00debug_file_release,
.read = rt2x00debug_read_dev_flags,
.open = rt2x00debug_file_open,
.release = rt2x00debug_file_release,
+ .llseek = default_llseek,
};
static struct dentry *rt2x00debug_create_file_driver(const char *name,
};
static struct dentry *rt2x00debug_create_file_driver(const char *name,
static const struct file_operations tx_queue_len_ops = {
.read = tx_queue_len_read,
.open = wl1251_open_file_generic,
static const struct file_operations tx_queue_len_ops = {
.read = tx_queue_len_read,
.open = wl1251_open_file_generic,
+ .llseek = generic_file_llseek,
};
static ssize_t tx_queue_status_read(struct file *file, char __user *userbuf,
};
static ssize_t tx_queue_status_read(struct file *file, char __user *userbuf,
static const struct file_operations tx_queue_status_ops = {
.read = tx_queue_status_read,
.open = wl1251_open_file_generic,
static const struct file_operations tx_queue_status_ops = {
.read = tx_queue_status_read,
.open = wl1251_open_file_generic,
+ .llseek = generic_file_llseek,
};
static void wl1251_debugfs_delete_files(struct wl1251 *wl)
};
static void wl1251_debugfs_delete_files(struct wl1251 *wl)
static const struct file_operations tx_queue_len_ops = {
.read = tx_queue_len_read,
.open = wl1271_open_file_generic,
static const struct file_operations tx_queue_len_ops = {
.read = tx_queue_len_read,
.open = wl1271_open_file_generic,
+ .llseek = default_llseek,
};
static ssize_t gpio_power_read(struct file *file, char __user *user_buf,
};
static ssize_t gpio_power_read(struct file *file, char __user *user_buf,
static const struct file_operations gpio_power_ops = {
.read = gpio_power_read,
.write = gpio_power_write,
static const struct file_operations gpio_power_ops = {
.read = gpio_power_read,
.write = gpio_power_write,
- .open = wl1271_open_file_generic
+ .open = wl1271_open_file_generic,
+ .llseek = default_llseek,
};
static void wl1271_debugfs_delete_files(struct wl1271 *wl)
};
static void wl1271_debugfs_delete_files(struct wl1271 *wl)
static const struct file_operations timeout_fops = {
.read = timeout_read,
.write = timeout_write,
static const struct file_operations timeout_fops = {
.read = timeout_read,
.write = timeout_write,
+ .llseek = default_llseek,
static const struct file_operations depth_fops = {
.read = depth_read,
static const struct file_operations depth_fops = {
.read = depth_read,
+ .write = depth_write,
+ .llseek = default_llseek,
static const struct file_operations pointer_size_fops = {
.read = pointer_size_read,
static const struct file_operations pointer_size_fops = {
.read = pointer_size_read,
+ .llseek = default_llseek,
static const struct file_operations cpu_type_fops = {
.read = cpu_type_read,
static const struct file_operations cpu_type_fops = {
.read = cpu_type_read,
+ .llseek = default_llseek,
static const struct file_operations enable_fops = {
.read = enable_read,
.write = enable_write,
static const struct file_operations enable_fops = {
.read = enable_read,
.write = enable_write,
+ .llseek = default_llseek,
static const struct file_operations dump_fops = {
.write = dump_write,
static const struct file_operations dump_fops = {
.write = dump_write,
};
void oprofile_create_files(struct super_block *sb, struct dentry *root)
};
void oprofile_create_files(struct super_block *sb, struct dentry *root)
.read = ulong_read_file,
.write = ulong_write_file,
.open = default_open,
.read = ulong_read_file,
.write = ulong_write_file,
.open = default_open,
+ .llseek = default_llseek,
};
static const struct file_operations ulong_ro_fops = {
.read = ulong_read_file,
.open = default_open,
};
static const struct file_operations ulong_ro_fops = {
.read = ulong_read_file,
.open = default_open,
+ .llseek = default_llseek,
static const struct file_operations atomic_ro_fops = {
.read = atomic_read_file,
.open = default_open,
static const struct file_operations atomic_ro_fops = {
.read = atomic_read_file,
.open = default_open,
+ .llseek = default_llseek,
static const struct file_operations aer_inject_fops = {
.write = aer_inject_write,
.owner = THIS_MODULE,
static const struct file_operations aer_inject_fops = {
.write = aer_inject_write,
.owner = THIS_MODULE,
};
static struct miscdevice aer_inject_device = {
};
static struct miscdevice aer_inject_device = {
.release = sonypi_misc_release,
.fasync = sonypi_misc_fasync,
.unlocked_ioctl = sonypi_misc_ioctl,
.release = sonypi_misc_release,
.fasync = sonypi_misc_fasync,
.unlocked_ioctl = sonypi_misc_ioctl,
};
static struct miscdevice sonypi_misc_device = {
};
static struct miscdevice sonypi_misc_device = {
.write = wdt_write,
.open = wdt_open,
.release = wdt_release,
.write = wdt_write,
.open = wdt_open,
.release = wdt_release,
};
static struct miscdevice wdt_dev = {
};
static struct miscdevice wdt_dev = {
.read = &dasd_eer_read,
.poll = &dasd_eer_poll,
.owner = THIS_MODULE,
.read = &dasd_eer_read,
.poll = &dasd_eer_poll,
.owner = THIS_MODULE,
};
static struct miscdevice *dasd_eer_dev = NULL;
};
static struct miscdevice *dasd_eer_dev = NULL;
.compat_ioctl = fs3270_ioctl, /* ioctl */
.open = fs3270_open, /* open */
.release = fs3270_close, /* release */
.compat_ioctl = fs3270_ioctl, /* ioctl */
.open = fs3270_open, /* open */
.release = fs3270_close, /* release */
.release = &mon_close,
.read = &mon_read,
.poll = &mon_poll,
.release = &mon_close,
.read = &mon_read,
.poll = &mon_poll,
};
static struct miscdevice mon_dev = {
};
static struct miscdevice mon_dev = {
.open = &monwrite_open,
.release = &monwrite_close,
.write = &monwrite_write,
.open = &monwrite_open,
.release = &monwrite_close,
.write = &monwrite_write,
};
static struct miscdevice mon_dev = {
};
static struct miscdevice mon_dev = {
#endif
.open = tapechar_open,
.release = tapechar_release,
#endif
.open = tapechar_open,
.release = tapechar_release,
};
static int tapechar_major = TAPECHAR_MAJOR;
};
static int tapechar_major = TAPECHAR_MAJOR;
.write = vmcp_write,
.unlocked_ioctl = vmcp_ioctl,
.compat_ioctl = vmcp_ioctl,
.write = vmcp_write,
.unlocked_ioctl = vmcp_ioctl,
.compat_ioctl = vmcp_ioctl,
};
static struct miscdevice vmcp_dev = {
};
static struct miscdevice vmcp_dev = {
.open = vmlogrdr_open,
.release = vmlogrdr_release,
.read = vmlogrdr_read,
.open = vmlogrdr_open,
.release = vmlogrdr_release,
.read = vmlogrdr_read,
.unlocked_ioctl = &vmwdt_ioctl,
.write = &vmwdt_write,
.owner = THIS_MODULE,
.unlocked_ioctl = &vmwdt_ioctl,
.write = &vmwdt_write,
.owner = THIS_MODULE,
};
static struct miscdevice vmwdt_dev = {
};
static struct miscdevice vmwdt_dev = {
.read = zcore_memmap_read,
.open = zcore_memmap_open,
.release = zcore_memmap_release,
.read = zcore_memmap_read,
.open = zcore_memmap_open,
.release = zcore_memmap_release,
};
static ssize_t zcore_reipl_write(struct file *filp, const char __user *buf,
};
static ssize_t zcore_reipl_write(struct file *filp, const char __user *buf,
.write = zcore_reipl_write,
.open = zcore_reipl_open,
.release = zcore_reipl_release,
.write = zcore_reipl_write,
.open = zcore_reipl_open,
.release = zcore_reipl_release,
.open = nonseekable_open,
.unlocked_ioctl = chsc_ioctl,
.compat_ioctl = chsc_ioctl,
.open = nonseekable_open,
.unlocked_ioctl = chsc_ioctl,
.compat_ioctl = chsc_ioctl,
};
static struct miscdevice chsc_misc_device = {
};
static struct miscdevice chsc_misc_device = {
static const struct file_operations cio_settle_proc_fops = {
.open = nonseekable_open,
.write = cio_settle_write,
static const struct file_operations cio_settle_proc_fops = {
.open = nonseekable_open,
.write = cio_settle_write,
};
static int __init cio_settle_init(void)
};
static int __init cio_settle_init(void)
.compat_ioctl = zcrypt_compat_ioctl,
#endif
.open = zcrypt_open,
.compat_ioctl = zcrypt_compat_ioctl,
#endif
.open = zcrypt_open,
- .release = zcrypt_release
+ .release = zcrypt_release,
+ .llseek = no_llseek,
.open = nonseekable_open,
.unlocked_ioctl = zfcp_cfdc_dev_ioctl,
#ifdef CONFIG_COMPAT
.open = nonseekable_open,
.unlocked_ioctl = zfcp_cfdc_dev_ioctl,
#ifdef CONFIG_COMPAT
- .compat_ioctl = zfcp_cfdc_dev_ioctl
+ .compat_ioctl = zfcp_cfdc_dev_ioctl,
};
struct miscdevice zfcp_cfdc_misc = {
};
struct miscdevice zfcp_cfdc_misc = {
.compat_ioctl = d7s_ioctl,
.open = d7s_open,
.release = d7s_release,
.compat_ioctl = d7s_ioctl,
.open = d7s_open,
.release = d7s_release,
};
static struct miscdevice d7s_miscdev = {
};
static struct miscdevice d7s_miscdev = {
#endif
.open = envctrl_open,
.release = envctrl_release,
#endif
.open = envctrl_open,
.release = envctrl_release,
};
static struct miscdevice envctrl_dev = {
};
static struct miscdevice envctrl_dev = {
.owner = THIS_MODULE,
.unlocked_ioctl = twa_chrdev_ioctl,
.open = twa_chrdev_open,
.owner = THIS_MODULE,
.unlocked_ioctl = twa_chrdev_ioctl,
.open = twa_chrdev_open,
+ .release = NULL,
+ .llseek = noop_llseek,
};
/* This function will complete an aen request from the isr */
};
/* This function will complete an aen request from the isr */
.owner = THIS_MODULE,
.unlocked_ioctl = twl_chrdev_ioctl,
.open = twl_chrdev_open,
.owner = THIS_MODULE,
.unlocked_ioctl = twl_chrdev_ioctl,
.open = twl_chrdev_open,
+ .release = NULL,
+ .llseek = noop_llseek,
};
/* This function passes sense data from firmware to scsi layer */
};
/* This function passes sense data from firmware to scsi layer */
.owner = THIS_MODULE,
.unlocked_ioctl = tw_chrdev_ioctl,
.open = tw_chrdev_open,
.owner = THIS_MODULE,
.unlocked_ioctl = tw_chrdev_ioctl,
.open = tw_chrdev_open,
+ .release = NULL,
+ .llseek = noop_llseek,
};
/* This function will free up device extension resources */
};
/* This function will free up device extension resources */
.compat_ioctl = aac_compat_cfg_ioctl,
#endif
.open = aac_cfg_open,
.compat_ioctl = aac_compat_cfg_ioctl,
#endif
.open = aac_cfg_open,
};
static struct scsi_host_template aac_driver_template = {
};
static struct scsi_host_template aac_driver_template = {
#ifdef CONFIG_COMPAT
.compat_ioctl = ch_ioctl_compat,
#endif
#ifdef CONFIG_COMPAT
.compat_ioctl = ch_ioctl_compat,
#endif
};
static int __init init_ch_module(void)
};
static int __init init_ch_module(void)
#ifdef CONFIG_COMPAT
.compat_ioctl = compat_adpt_ioctl,
#endif
#ifdef CONFIG_COMPAT
.compat_ioctl = compat_adpt_ioctl,
#endif
};
/* Structures and definitions for synchronous message posting.
};
/* Structures and definitions for synchronous message posting.
.unlocked_ioctl = gdth_unlocked_ioctl,
.open = gdth_open,
.release = gdth_close,
.unlocked_ioctl = gdth_unlocked_ioctl,
.open = gdth_open,
.release = gdth_close,
};
#include "gdth_proc.h"
};
#include "gdth_proc.h"
.owner = THIS_MODULE,
.unlocked_ioctl = megadev_unlocked_ioctl,
.open = megadev_open,
.owner = THIS_MODULE,
.unlocked_ioctl = megadev_unlocked_ioctl,
.open = megadev_open,
.compat_ioctl = mraid_mm_compat_ioctl,
#endif
.owner = THIS_MODULE,
.compat_ioctl = mraid_mm_compat_ioctl,
#endif
.owner = THIS_MODULE,
};
static struct miscdevice megaraid_mm_dev = {
};
static struct miscdevice megaraid_mm_dev = {
#ifdef CONFIG_COMPAT
.compat_ioctl = megasas_mgmt_compat_ioctl,
#endif
#ifdef CONFIG_COMPAT
.compat_ioctl = megasas_mgmt_compat_ioctl,
#endif
#ifdef CONFIG_COMPAT
.compat_ioctl = _ctl_ioctl_compat,
#endif
#ifdef CONFIG_COMPAT
.compat_ioctl = _ctl_ioctl_compat,
#endif
};
static struct miscdevice ctl_dev = {
};
static struct miscdevice ctl_dev = {
.open = osd_uld_open,
.release = osd_uld_release,
.unlocked_ioctl = osd_uld_ioctl,
.open = osd_uld_open,
.release = osd_uld_release,
.unlocked_ioctl = osd_uld_ioctl,
};
struct osd_dev *osduld_path_lookup(const char *name)
};
struct osd_dev *osduld_path_lookup(const char *name)
#ifdef CONFIG_COMPAT
.compat_ioctl = pmcraid_chr_ioctl,
#endif
#ifdef CONFIG_COMPAT
.compat_ioctl = pmcraid_chr_ioctl,
#endif
static struct file_operations apidev_fops = {
.owner = THIS_MODULE,
static struct file_operations apidev_fops = {
.owner = THIS_MODULE,
.poll = tgt_poll,
.write = tgt_write,
.mmap = tgt_mmap,
.poll = tgt_poll,
.write = tgt_write,
.mmap = tgt_mmap,
};
static struct miscdevice tgt_miscdev = {
};
static struct miscdevice tgt_miscdev = {
.mmap = sg_mmap,
.release = sg_release,
.fasync = sg_fasync,
.mmap = sg_mmap,
.release = sg_release,
.fasync = sg_fasync,
};
static struct class *sg_sysfs_class;
};
static struct class *sg_sysfs_class;
.owner = THIS_MODULE,
.open = hsu_show_regs_open,
.read = port_show_regs,
.owner = THIS_MODULE,
.open = hsu_show_regs_open,
.read = port_show_regs,
+ .llseek = default_llseek,
};
static const struct file_operations dma_regs_ops = {
.owner = THIS_MODULE,
.open = hsu_show_regs_open,
.read = dma_show_regs,
};
static const struct file_operations dma_regs_ops = {
.owner = THIS_MODULE,
.open = hsu_show_regs_open,
.read = dma_show_regs,
+ .llseek = default_llseek,
};
static int hsu_debugfs_init(struct hsu_port *hsu)
};
static int hsu_debugfs_init(struct hsu_port *hsu)
.owner = THIS_MODULE,
.open = spi_show_regs_open,
.read = spi_show_regs,
.owner = THIS_MODULE,
.open = spi_show_regs_open,
.read = spi_show_regs,
+ .llseek = default_llseek,
};
static int mrst_spi_debugfs_init(struct dw_spi *dws)
};
static int mrst_spi_debugfs_init(struct dw_spi *dws)
.unlocked_ioctl = spidev_ioctl,
.open = spidev_open,
.release = spidev_release,
.unlocked_ioctl = spidev_ioctl,
.open = spidev_open,
.release = spidev_release,
};
/*-------------------------------------------------------------------------*/
};
/*-------------------------------------------------------------------------*/
.mmap = comedi_mmap,
.poll = comedi_poll,
.fasync = comedi_fasync,
.mmap = comedi_mmap,
.poll = comedi_poll,
.fasync = comedi_fasync,
};
struct class *comedi_class;
};
struct class *comedi_class;
.unlocked_ioctl = chd_dec_ioctl,
.open = chd_dec_open,
.release = chd_dec_close,
.unlocked_ioctl = chd_dec_ioctl,
.open = chd_dec_open,
.release = chd_dec_close,
};
static int __devinit chd_dec_init_chdev(struct crystalhd_adp *adp)
};
static int __devinit chd_dec_init_chdev(struct crystalhd_adp *adp)
.open = msm_open,
.unlocked_ioctl = msm_ioctl_config,
.release = msm_release_config,
.open = msm_open,
.unlocked_ioctl = msm_ioctl_config,
.release = msm_release_config,
};
static const struct file_operations msm_fops_control = {
};
static const struct file_operations msm_fops_control = {
.open = msm_open_control,
.unlocked_ioctl = msm_ioctl_control,
.release = msm_release_control,
.open = msm_open_control,
.unlocked_ioctl = msm_ioctl_control,
.release = msm_release_control,
};
static const struct file_operations msm_fops_frame = {
};
static const struct file_operations msm_fops_frame = {
.unlocked_ioctl = msm_ioctl_frame,
.release = msm_release_frame,
.poll = msm_poll_frame,
.unlocked_ioctl = msm_ioctl_frame,
.release = msm_release_frame,
.poll = msm_poll_frame,
};
static int msm_setup_cdev(struct msm_device *msm,
};
static int msm_setup_cdev(struct msm_device *msm,
.mmap = pmem_mmap,
.open = pmem_open,
.unlocked_ioctl = pmem_ioctl,
.mmap = pmem_mmap,
.open = pmem_open,
.unlocked_ioctl = pmem_ioctl,
};
static int get_id(struct file *file)
};
static int get_id(struct file *file)
static struct file_operations debug_fops = {
.read = debug_read,
.open = debug_open,
static struct file_operations debug_fops = {
.read = debug_read,
.open = debug_open,
+ .llseek = default_llseek,
.open = adsp_open,
.unlocked_ioctl = adsp_ioctl,
.release = adsp_release,
.open = adsp_open,
.unlocked_ioctl = adsp_ioctl,
.release = adsp_release,
};
static void adsp_create(struct adsp_device *adev, const char *name,
};
static void adsp_create(struct adsp_device *adev, const char *name,
.read = audio_read,
.write = audio_write,
.unlocked_ioctl = audio_ioctl,
.read = audio_read,
.write = audio_write,
.unlocked_ioctl = audio_ioctl,
};
struct miscdevice audio_aac_misc = {
};
struct miscdevice audio_aac_misc = {
.read = audamrnb_read,
.write = audamrnb_write,
.unlocked_ioctl = audamrnb_ioctl,
.read = audamrnb_read,
.write = audamrnb_write,
.unlocked_ioctl = audamrnb_ioctl,
};
struct miscdevice audio_amrnb_misc = {
};
struct miscdevice audio_amrnb_misc = {
.read = audevrc_read,
.write = audevrc_write,
.unlocked_ioctl = audevrc_ioctl,
.read = audevrc_read,
.write = audevrc_write,
.unlocked_ioctl = audevrc_ioctl,
};
struct miscdevice audio_evrc_misc = {
};
struct miscdevice audio_evrc_misc = {
.read = audio_in_read,
.write = audio_in_write,
.unlocked_ioctl = audio_in_ioctl,
.read = audio_in_read,
.write = audio_in_write,
.unlocked_ioctl = audio_in_ioctl,
};
static struct file_operations audpre_fops = {
.owner = THIS_MODULE,
.open = audpre_open,
.unlocked_ioctl = audpre_ioctl,
};
static struct file_operations audpre_fops = {
.owner = THIS_MODULE,
.open = audpre_open,
.unlocked_ioctl = audpre_ioctl,
};
struct miscdevice audio_in_misc = {
};
struct miscdevice audio_in_misc = {
.read = audio_read,
.write = audio_write,
.unlocked_ioctl = audio_ioctl,
.read = audio_read,
.write = audio_write,
.unlocked_ioctl = audio_ioctl,
};
struct miscdevice audio_mp3_misc = {
};
struct miscdevice audio_mp3_misc = {
.read = audio_read,
.write = audio_write,
.unlocked_ioctl = audio_ioctl,
.read = audio_read,
.write = audio_write,
.unlocked_ioctl = audio_ioctl,
};
static struct file_operations audpp_fops = {
.owner = THIS_MODULE,
.open = audpp_open,
.unlocked_ioctl = audpp_ioctl,
};
static struct file_operations audpp_fops = {
.owner = THIS_MODULE,
.open = audpp_open,
.unlocked_ioctl = audpp_ioctl,
};
struct miscdevice audio_misc = {
};
struct miscdevice audio_misc = {
.read = audqcelp_read,
.write = audqcelp_write,
.unlocked_ioctl = audqcelp_ioctl,
.read = audqcelp_read,
.write = audqcelp_write,
.unlocked_ioctl = audqcelp_ioctl,
};
struct miscdevice audio_qcelp_misc = {
};
struct miscdevice audio_qcelp_misc = {
static const struct file_operations ev_log_ops = {
.read = ev_log_read,
.open = ev_log_open,
static const struct file_operations ev_log_ops = {
.read = ev_log_read,
.open = ev_log_open,
+ .llseek = default_llseek,
};
static int ev_log_init(struct ev_log *log)
};
static int ev_log_init(struct ev_log *log)
.open = snd_open,
.release = snd_release,
.unlocked_ioctl = snd_ioctl,
.open = snd_open,
.release = snd_release,
.unlocked_ioctl = snd_ioctl,
};
struct miscdevice snd_misc = {
};
struct miscdevice snd_misc = {
.open = usb_alphatrack_open,
.release = usb_alphatrack_release,
.poll = usb_alphatrack_poll,
.open = usb_alphatrack_open,
.release = usb_alphatrack_release,
.poll = usb_alphatrack_poll,
.open = usb_tranzport_open,
.release = usb_tranzport_release,
.poll = usb_tranzport_poll,
.open = usb_tranzport_open,
.release = usb_tranzport_release,
.poll = usb_tranzport_poll,
.release = iio_event_chrdev_release,
.open = iio_event_chrdev_open,
.owner = THIS_MODULE,
.release = iio_event_chrdev_release,
.open = iio_event_chrdev_open,
.owner = THIS_MODULE,
};
static void iio_event_dev_release(struct device *dev)
};
static void iio_event_dev_release(struct device *dev)
.release = iio_ring_release,
.open = iio_ring_open,
.owner = THIS_MODULE,
.release = iio_ring_release,
.open = iio_ring_open,
.owner = THIS_MODULE,
.owner = THIS_MODULE,
.open = &display_open,
.write = &vfd_write,
.owner = THIS_MODULE,
.open = &display_open,
.write = &vfd_write,
- .release = &display_close
+ .release = &display_close,
+ .llseek = noop_llseek,
.unlocked_ioctl = lirc_ioctl,
.open = lirc_open,
.release = lirc_close,
.unlocked_ioctl = lirc_ioctl,
.open = lirc_open,
.release = lirc_close,
};
static int set_use_inc(void *data)
};
static int set_use_inc(void *data)
.write = &vfd_write,
.unlocked_ioctl = &vfd_ioctl,
.release = &vfd_close,
.write = &vfd_write,
.unlocked_ioctl = &vfd_ioctl,
.release = &vfd_close,
};
/* USB Device ID for Sasem USB Control Board */
};
/* USB Device ID for Sasem USB Control Board */
.mmap = memrar_mmap,
.open = memrar_open,
.release = memrar_release,
.mmap = memrar_mmap,
.open = memrar_open,
.release = memrar_release,
};
static struct miscdevice memrar_miscdev = {
};
static struct miscdevice memrar_miscdev = {
.read = keypad_read, /* read */
.open = keypad_open, /* open */
.release = keypad_release, /* close */
.read = keypad_read, /* read */
.open = keypad_open, /* open */
.release = keypad_release, /* close */
+ .llseek = default_llseek,
};
static struct miscdevice keypad_dev = {
};
static struct miscdevice keypad_dev = {
.release = bridge_release,
.unlocked_ioctl = bridge_ioctl,
.mmap = bridge_mmap,
.release = bridge_release,
.unlocked_ioctl = bridge_ioctl,
.mmap = bridge_mmap,
.poll = ixj_poll,
.unlocked_ioctl = ixj_ioctl,
.release = ixj_release,
.poll = ixj_poll,
.unlocked_ioctl = ixj_ioctl,
.release = ixj_release,
+ .fasync = ixj_fasync,
+ .llseek = default_llseek,
};
static int ixj_linetest(IXJ *j)
};
static int ixj_linetest(IXJ *j)
{
.owner = THIS_MODULE,
.open = phone_open,
{
.owner = THIS_MODULE,
.open = phone_open,
.mmap = uio_mmap,
.poll = uio_poll,
.fasync = uio_fasync,
.mmap = uio_mmap,
.poll = uio_poll,
.fasync = uio_fasync,
};
static int uio_major_init(void)
};
static int uio_major_init(void)
.open = wdm_open,
.flush = wdm_flush,
.release = wdm_release,
.open = wdm_open,
.flush = wdm_flush,
.release = wdm_release,
+ .poll = wdm_poll,
+ .llseek = noop_llseek,
};
static struct usb_class_driver wdm_class = {
};
static struct usb_class_driver wdm_class = {
.compat_ioctl = usblp_ioctl,
.open = usblp_open,
.release = usblp_release,
.compat_ioctl = usblp_ioctl,
.open = usblp_open,
.release = usblp_release,
};
static char *usblp_devnode(struct device *dev, mode_t *mode)
};
static char *usblp_devnode(struct device *dev, mode_t *mode)
.open = usbtmc_open,
.release = usbtmc_release,
.unlocked_ioctl = usbtmc_ioctl,
.open = usbtmc_open,
.release = usbtmc_release,
.unlocked_ioctl = usbtmc_ioctl,
+ .llseek = default_llseek,
};
static struct usb_class_driver usbtmc_class = {
};
static struct usb_class_driver usbtmc_class = {
static const struct file_operations usb_fops = {
.owner = THIS_MODULE,
.open = usb_open,
static const struct file_operations usb_fops = {
.owner = THIS_MODULE,
.open = usb_open,
};
static struct usb_class {
};
static struct usb_class {
.write = f_hidg_write,
.read = f_hidg_read,
.poll = f_hidg_poll,
.write = f_hidg_write,
.read = f_hidg_read,
.poll = f_hidg_poll,
};
static int __init hidg_bind(struct usb_configuration *c, struct usb_function *f)
};
static int __init hidg_bind(struct usb_configuration *c, struct usb_function *f)
.fsync = printer_fsync,
.poll = printer_poll,
.unlocked_ioctl = printer_ioctl,
.fsync = printer_fsync,
.poll = printer_poll,
.unlocked_ioctl = printer_ioctl,
- .release = printer_close
+ .release = printer_close,
+ .llseek = noop_llseek,
};
/*-------------------------------------------------------------------------*/
};
/*-------------------------------------------------------------------------*/
.open = debug_async_open,
.read = debug_output,
.release = debug_close,
.open = debug_async_open,
.read = debug_output,
.release = debug_close,
+ .llseek = default_llseek,
};
static const struct file_operations debug_periodic_fops = {
.owner = THIS_MODULE,
.open = debug_periodic_open,
.read = debug_output,
.release = debug_close,
};
static const struct file_operations debug_periodic_fops = {
.owner = THIS_MODULE,
.open = debug_periodic_open,
.read = debug_output,
.release = debug_close,
+ .llseek = default_llseek,
};
static const struct file_operations debug_registers_fops = {
.owner = THIS_MODULE,
.open = debug_registers_open,
.read = debug_output,
.release = debug_close,
};
static const struct file_operations debug_registers_fops = {
.owner = THIS_MODULE,
.open = debug_registers_open,
.read = debug_output,
.release = debug_close,
+ .llseek = default_llseek,
};
static const struct file_operations debug_lpm_fops = {
.owner = THIS_MODULE,
};
static const struct file_operations debug_lpm_fops = {
.owner = THIS_MODULE,
.read = debug_lpm_read,
.write = debug_lpm_write,
.release = debug_lpm_close,
.read = debug_lpm_read,
.write = debug_lpm_write,
.release = debug_lpm_close,
};
static struct dentry *ehci_debug_root;
};
static struct dentry *ehci_debug_root;
.open = debug_async_open,
.read = debug_output,
.release = debug_close,
.open = debug_async_open,
.read = debug_output,
.release = debug_close,
+ .llseek = default_llseek,
};
static const struct file_operations debug_periodic_fops = {
.owner = THIS_MODULE,
.open = debug_periodic_open,
.read = debug_output,
.release = debug_close,
};
static const struct file_operations debug_periodic_fops = {
.owner = THIS_MODULE,
.open = debug_periodic_open,
.read = debug_output,
.release = debug_close,
+ .llseek = default_llseek,
};
static const struct file_operations debug_registers_fops = {
.owner = THIS_MODULE,
.open = debug_registers_open,
.read = debug_output,
.release = debug_close,
};
static const struct file_operations debug_registers_fops = {
.owner = THIS_MODULE,
.open = debug_registers_open,
.read = debug_output,
.release = debug_close,
+ .llseek = default_llseek,
};
static struct dentry *ohci_debug_root;
};
static struct dentry *ohci_debug_root;
.write = mdc800_device_write,
.open = mdc800_device_open,
.release = mdc800_device_release,
.write = mdc800_device_write,
.open = mdc800_device_open,
.release = mdc800_device_release,
.write = adu_write,
.open = adu_open,
.release = adu_release,
.write = adu_write,
.open = adu_open,
.release = adu_release,
.read = idmouse_read,
.open = idmouse_open,
.release = idmouse_release,
.read = idmouse_read,
.open = idmouse_open,
.release = idmouse_release,
+ .llseek = default_llseek,
};
/* class driver information */
};
/* class driver information */
.open = iowarrior_open,
.release = iowarrior_release,
.poll = iowarrior_poll,
.open = iowarrior_open,
.release = iowarrior_release,
.poll = iowarrior_poll,
};
static char *iowarrior_devnode(struct device *dev, mode_t *mode)
};
static char *iowarrior_devnode(struct device *dev, mode_t *mode)
.open = ld_usb_open,
.release = ld_usb_release,
.poll = ld_usb_poll,
.open = ld_usb_open,
.release = ld_usb_release,
.poll = ld_usb_poll,
.unlocked_ioctl = ioctl_rio,
.open = open_rio,
.release = close_rio,
.unlocked_ioctl = ioctl_rio,
.open = open_rio,
.release = close_rio,
};
static struct usb_class_driver usb_rio_class = {
};
static struct usb_class_driver usb_rio_class = {
.open = lcd_open,
.unlocked_ioctl = lcd_ioctl,
.release = lcd_release,
.open = lcd_open,
.unlocked_ioctl = lcd_ioctl,
.release = lcd_release,
.open = skel_open,
.release = skel_release,
.flush = skel_flush,
.open = skel_open,
.release = skel_release,
.flush = skel_flush,
.compat_ioctl = vhost_net_compat_ioctl,
#endif
.open = vhost_net_open,
.compat_ioctl = vhost_net_compat_ioctl,
#endif
.open = vhost_net_open,
};
static struct miscdevice vhost_net_misc = {
};
static struct miscdevice vhost_net_misc = {
#ifdef CONFIG_FB_DEFERRED_IO
.fsync = fb_deferred_io_fsync,
#endif
#ifdef CONFIG_FB_DEFERRED_IO
.fsync = fb_deferred_io_fsync,
#endif
+ .llseek = default_llseek,
};
struct class *fb_class;
};
struct class *fb_class;
.read = sysconf_read_file,
.write = write_file_dummy,
.open = open_file_generic,
.read = sysconf_read_file,
.write = write_file_dummy,
.open = open_file_generic,
+ .llseek = default_llseek,
};
static const struct file_operations clock_fops = {
.read = clock_read_file,
.write = write_file_dummy,
.open = open_file_generic,
};
static const struct file_operations clock_fops = {
.read = clock_read_file,
.write = write_file_dummy,
.open = open_file_generic,
+ .llseek = default_llseek,
};
static const struct file_operations display_fops = {
.read = display_read_file,
.write = write_file_dummy,
.open = open_file_generic,
};
static const struct file_operations display_fops = {
.read = display_read_file,
.write = write_file_dummy,
.open = open_file_generic,
+ .llseek = default_llseek,
};
static const struct file_operations gsctl_fops = {
.read = gsctl_read_file,
.write = write_file_dummy,
.open = open_file_generic,
};
static const struct file_operations gsctl_fops = {
.read = gsctl_read_file,
.write = write_file_dummy,
.open = open_file_generic,
+ .llseek = default_llseek,
};
static const struct file_operations sdram_fops = {
.read = sdram_read_file,
.write = write_file_dummy,
.open = open_file_generic,
};
static const struct file_operations sdram_fops = {
.read = sdram_read_file,
.write = write_file_dummy,
.open = open_file_generic,
+ .llseek = default_llseek,
};
static const struct file_operations misc_fops = {
.read = misc_read_file,
.write = write_file_dummy,
.open = open_file_generic,
};
static const struct file_operations misc_fops = {
.read = misc_read_file,
.write = write_file_dummy,
.open = open_file_generic,
+ .llseek = default_llseek,
};
static void __devinit mbxfb_debugfs_init(struct fb_info *fbi)
};
static void __devinit mbxfb_debugfs_init(struct fb_info *fbi)
.unlocked_ioctl = ar7_wdt_ioctl,
.open = ar7_wdt_open,
.release = ar7_wdt_release,
.unlocked_ioctl = ar7_wdt_ioctl,
.open = ar7_wdt_open,
.release = ar7_wdt_release,
};
static struct miscdevice ar7_wdt_miscdev = {
};
static struct miscdevice ar7_wdt_miscdev = {
.write = cpwd_write,
.read = cpwd_read,
.release = cpwd_release,
.write = cpwd_write,
.read = cpwd_read,
.release = cpwd_release,
};
static int __devinit cpwd_probe(struct platform_device *op,
};
static int __devinit cpwd_probe(struct platform_device *op,
.unlocked_ioctl = ep93xx_wdt_ioctl,
.open = ep93xx_wdt_open,
.release = ep93xx_wdt_release,
.unlocked_ioctl = ep93xx_wdt_ioctl,
.open = ep93xx_wdt_open,
.release = ep93xx_wdt_release,
};
static struct miscdevice ep93xx_wdt_miscdev = {
};
static struct miscdevice ep93xx_wdt_miscdev = {
.unlocked_ioctl = omap_wdt_ioctl,
.open = omap_wdt_open,
.release = omap_wdt_release,
.unlocked_ioctl = omap_wdt_ioctl,
.open = omap_wdt_open,
.release = omap_wdt_release,
};
static int __devinit omap_wdt_probe(struct platform_device *pdev)
};
static int __devinit omap_wdt_probe(struct platform_device *pdev)
.fasync = evtchn_fasync,
.open = evtchn_open,
.release = evtchn_release,
.fasync = evtchn_fasync,
.open = evtchn_open,
.release = evtchn_release,
};
static struct miscdevice evtchn_miscdev = {
};
static struct miscdevice evtchn_miscdev = {
static const struct file_operations capabilities_file_ops = {
.read = capabilities_read,
static const struct file_operations capabilities_file_ops = {
.read = capabilities_read,
+ .llseek = default_llseek,
};
static int xenfs_fill_super(struct super_block *sb, void *data, int silent)
};
static int xenfs_fill_super(struct super_block *sb, void *data, int silent)
.open = xenbus_file_open,
.release = xenbus_file_release,
.poll = xenbus_file_poll,
.open = xenbus_file_open,
.release = xenbus_file_release,
.poll = xenbus_file_poll,
const struct file_operations afs_mntpt_file_operations = {
.open = afs_mntpt_open,
const struct file_operations afs_mntpt_file_operations = {
.open = afs_mntpt_open,
};
const struct inode_operations afs_mntpt_inode_operations = {
};
const struct inode_operations afs_mntpt_inode_operations = {
.unlocked_ioctl = autofs_dev_ioctl,
.compat_ioctl = autofs_dev_ioctl_compat,
.owner = THIS_MODULE,
.unlocked_ioctl = autofs_dev_ioctl,
.compat_ioctl = autofs_dev_ioctl_compat,
.owner = THIS_MODULE,
};
static struct miscdevice _autofs_dev_ioctl_misc = {
};
static struct miscdevice _autofs_dev_ioctl_misc = {
static const struct file_operations bm_entry_operations = {
.read = bm_entry_read,
.write = bm_entry_write,
static const struct file_operations bm_entry_operations = {
.read = bm_entry_read,
.write = bm_entry_write,
+ .llseek = default_llseek,
static const struct file_operations bm_register_operations = {
.write = bm_register_write,
static const struct file_operations bm_register_operations = {
.write = bm_register_write,
static const struct file_operations bm_status_operations = {
.read = bm_status_read,
.write = bm_status_write,
static const struct file_operations bm_status_operations = {
.read = bm_status_read,
.write = bm_status_write,
+ .llseek = default_llseek,
};
/* Superblock handling */
};
/* Superblock handling */
.unlocked_ioctl = btrfs_control_ioctl,
.compat_ioctl = btrfs_control_ioctl,
.owner = THIS_MODULE,
.unlocked_ioctl = btrfs_control_ioctl,
.compat_ioctl = btrfs_control_ioctl,
.owner = THIS_MODULE,
};
static struct miscdevice btrfs_misc = {
};
static struct miscdevice btrfs_misc = {
.read = cachefiles_daemon_read,
.write = cachefiles_daemon_write,
.poll = cachefiles_daemon_poll,
.read = cachefiles_daemon_read,
.write = cachefiles_daemon_write,
.poll = cachefiles_daemon_poll,
};
struct cachefiles_daemon_cmd {
};
struct cachefiles_daemon_cmd {
*/
const struct file_operations def_chr_fops = {
.open = chrdev_open,
*/
const struct file_operations def_chr_fops = {
.open = chrdev_open,
};
static struct kobject *exact_match(dev_t dev, int *part, void *data)
};
static struct kobject *exact_match(dev_t dev, int *part, void *data)
const struct file_operations coda_ioctl_operations = {
.owner = THIS_MODULE,
.unlocked_ioctl = coda_pioctl,
const struct file_operations coda_ioctl_operations = {
.owner = THIS_MODULE,
.unlocked_ioctl = coda_pioctl,
};
/* the coda pioctl inode ops */
};
/* the coda pioctl inode ops */
.unlocked_ioctl = coda_psdev_ioctl,
.open = coda_psdev_open,
.release = coda_psdev_release,
.unlocked_ioctl = coda_psdev_ioctl,
.open = coda_psdev_open,
.release = coda_psdev_release,
};
static int init_coda_psdev(void)
};
static int init_coda_psdev(void)
.read = default_read_file,
.write = default_write_file,
.open = default_open,
.read = default_read_file,
.write = default_write_file,
.open = default_open,
};
static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
};
static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd)
.read = read_file_bool,
.write = write_file_bool,
.open = default_open,
.read = read_file_bool,
.write = write_file_bool,
.open = default_open,
+ .llseek = default_llseek,
static const struct file_operations fops_blob = {
.read = read_file_blob,
.open = default_open,
static const struct file_operations fops_blob = {
.read = read_file_blob,
.open = default_open,
+ .llseek = default_llseek,
static const struct file_operations waiters_fops = {
.owner = THIS_MODULE,
.open = waiters_open,
static const struct file_operations waiters_fops = {
.owner = THIS_MODULE,
.open = waiters_open,
+ .read = waiters_read,
+ .llseek = default_llseek,
};
void dlm_delete_debug_file(struct dlm_ls *ls)
};
void dlm_delete_debug_file(struct dlm_ls *ls)
.read = dev_read,
.write = dev_write,
.poll = dev_poll,
.read = dev_read,
.write = dev_write,
.poll = dev_poll,
+ .owner = THIS_MODULE,
+ .llseek = noop_llseek,
};
static struct miscdevice plock_dev_misc = {
};
static struct miscdevice plock_dev_misc = {
.write = device_write,
.poll = device_poll,
.owner = THIS_MODULE,
.write = device_write,
.poll = device_poll,
.owner = THIS_MODULE,
};
static const struct file_operations ctl_device_fops = {
};
static const struct file_operations ctl_device_fops = {
.read = device_read,
.write = device_write,
.owner = THIS_MODULE,
.read = device_read,
.write = device_write,
.owner = THIS_MODULE,
};
static struct miscdevice ctl_device = {
};
static struct miscdevice ctl_device = {
.open = monitor_device_open,
.release = monitor_device_close,
.owner = THIS_MODULE,
.open = monitor_device_open,
.release = monitor_device_close,
.owner = THIS_MODULE,
};
static struct miscdevice monitor_device = {
};
static struct miscdevice monitor_device = {
.fsync = ecryptfs_fsync,
.fasync = ecryptfs_fasync,
.splice_read = generic_file_splice_read,
.fsync = ecryptfs_fsync,
.fasync = ecryptfs_fasync,
.splice_read = generic_file_splice_read,
+ .llseek = default_llseek,
};
const struct file_operations ecryptfs_main_fops = {
};
const struct file_operations ecryptfs_main_fops = {
.read = ecryptfs_miscdev_read,
.write = ecryptfs_miscdev_write,
.release = ecryptfs_miscdev_release,
.read = ecryptfs_miscdev_read,
.write = ecryptfs_miscdev_write,
.release = ecryptfs_miscdev_release,
};
static struct miscdevice ecryptfs_miscdev = {
};
static struct miscdevice ecryptfs_miscdev = {
.poll = eventfd_poll,
.read = eventfd_read,
.write = eventfd_write,
.poll = eventfd_poll,
.read = eventfd_read,
.write = eventfd_write,
/* File callbacks that implement the eventpoll file behaviour */
static const struct file_operations eventpoll_fops = {
.release = ep_eventpoll_release,
/* File callbacks that implement the eventpoll file behaviour */
static const struct file_operations eventpoll_fops = {
.release = ep_eventpoll_release,
- .poll = ep_eventpoll_poll
+ .poll = ep_eventpoll_poll,
+ .llseek = noop_llseek,
};
/* Fast test to see if the file is an evenpoll file */
};
/* Fast test to see if the file is an evenpoll file */
*/
const struct file_operations def_fifo_fops = {
.open = fifo_open, /* will set read_ or write_pipefifo_fops */
*/
const struct file_operations def_fifo_fops = {
.open = fifo_open, /* will set read_ or write_pipefifo_fops */
static const struct file_operations fuse_ctl_abort_ops = {
.open = nonseekable_open,
.write = fuse_conn_abort_write,
static const struct file_operations fuse_ctl_abort_ops = {
.open = nonseekable_open,
.write = fuse_conn_abort_write,
};
static const struct file_operations fuse_ctl_waiting_ops = {
.open = nonseekable_open,
.read = fuse_conn_waiting_read,
};
static const struct file_operations fuse_ctl_waiting_ops = {
.open = nonseekable_open,
.read = fuse_conn_waiting_read,
};
static const struct file_operations fuse_conn_max_background_ops = {
.open = nonseekable_open,
.read = fuse_conn_max_background_read,
.write = fuse_conn_max_background_write,
};
static const struct file_operations fuse_conn_max_background_ops = {
.open = nonseekable_open,
.read = fuse_conn_max_background_read,
.write = fuse_conn_max_background_write,
};
static const struct file_operations fuse_conn_congestion_threshold_ops = {
.open = nonseekable_open,
.read = fuse_conn_congestion_threshold_read,
.write = fuse_conn_congestion_threshold_write,
};
static const struct file_operations fuse_conn_congestion_threshold_ops = {
.open = nonseekable_open,
.read = fuse_conn_congestion_threshold_read,
.write = fuse_conn_congestion_threshold_write,
};
static struct dentry *fuse_ctl_add_dentry(struct dentry *parent,
};
static struct dentry *fuse_ctl_add_dentry(struct dentry *parent,
.unlocked_ioctl = cuse_file_ioctl,
.compat_ioctl = cuse_file_compat_ioctl,
.poll = fuse_file_poll,
.unlocked_ioctl = cuse_file_ioctl,
.compat_ioctl = cuse_file_compat_ioctl,
.poll = fuse_file_poll,
.fsync = gfs2_fsync,
.lock = gfs2_lock,
.flock = gfs2_flock,
.fsync = gfs2_fsync,
.lock = gfs2_lock,
.flock = gfs2_flock,
+ .llseek = default_llseek,
};
#endif /* CONFIG_GFS2_FS_LOCKING_DLM */
};
#endif /* CONFIG_GFS2_FS_LOCKING_DLM */
.open = gfs2_open,
.release = gfs2_close,
.fsync = gfs2_fsync,
.open = gfs2_open,
.release = gfs2_close,
.fsync = gfs2_fsync,
+ .llseek = default_llseek,
.readdir = hppfs_readdir,
.open = hppfs_dir_open,
.fsync = hppfs_fsync,
.readdir = hppfs_readdir,
.open = hppfs_dir_open,
.fsync = hppfs_fsync,
+ .llseek = default_llseek,
};
static int hppfs_statfs(struct dentry *dentry, struct kstatfs *sf)
};
static int hppfs_statfs(struct dentry *dentry, struct kstatfs *sf)
.mmap = hugetlbfs_file_mmap,
.fsync = noop_fsync,
.get_unmapped_area = hugetlb_get_unmapped_area,
.mmap = hugetlbfs_file_mmap,
.fsync = noop_fsync,
.get_unmapped_area = hugetlb_get_unmapped_area,
+ .llseek = default_llseek,
};
static const struct inode_operations hugetlbfs_dir_inode_operations = {
};
static const struct inode_operations hugetlbfs_dir_inode_operations = {
.unlocked_ioctl = logfs_ioctl,
.readdir = logfs_readdir,
.read = generic_read_dir,
.unlocked_ioctl = logfs_ioctl,
.readdir = logfs_readdir,
.read = generic_read_dir,
+ .llseek = default_llseek,
.write = nfsctl_transaction_write,
.read = nfsctl_transaction_read,
.release = simple_transaction_release,
.write = nfsctl_transaction_write,
.read = nfsctl_transaction_read,
.release = simple_transaction_release,
+ .llseek = default_llseek,
};
static int exports_open(struct inode *inode, struct file *file)
};
static int exports_open(struct inode *inode, struct file *file)
const struct file_operations def_blk_fops = {
.open = no_blkdev_open,
const struct file_operations def_blk_fops = {
.open = no_blkdev_open,
.release = fanotify_release,
.unlocked_ioctl = fanotify_ioctl,
.compat_ioctl = fanotify_ioctl,
.release = fanotify_release,
.unlocked_ioctl = fanotify_ioctl,
.compat_ioctl = fanotify_ioctl,
};
static void fanotify_free_mark(struct fsnotify_mark *fsn_mark)
};
static void fanotify_free_mark(struct fsnotify_mark *fsn_mark)
.release = inotify_release,
.unlocked_ioctl = inotify_ioctl,
.compat_ioctl = inotify_ioctl,
.release = inotify_release,
.unlocked_ioctl = inotify_ioctl,
.compat_ioctl = inotify_ioctl,
.poll = dlmfs_file_poll,
.read = dlmfs_file_read,
.write = dlmfs_file_write,
.poll = dlmfs_file_poll,
.read = dlmfs_file_read,
.write = dlmfs_file_write,
+ .llseek = default_llseek,
};
static const struct inode_operations dlmfs_dir_inode_operations = {
};
static const struct inode_operations dlmfs_dir_inode_operations = {
.read = ocfs2_control_read,
.write = ocfs2_control_write,
.owner = THIS_MODULE,
.read = ocfs2_control_read,
.write = ocfs2_control_write,
.owner = THIS_MODULE,
+ .llseek = default_llseek,
};
static struct miscdevice ocfs2_control_device = {
};
static struct miscdevice ocfs2_control_device = {
static const struct file_operations proc_oom_score_adj_operations = {
.read = oom_score_adj_read,
.write = oom_score_adj_write,
static const struct file_operations proc_oom_score_adj_operations = {
.read = oom_score_adj_read,
.write = oom_score_adj_write,
+ .llseek = default_llseek,
};
#ifdef CONFIG_AUDITSYSCALL
};
#ifdef CONFIG_AUDITSYSCALL
static const struct file_operations proc_fdinfo_file_operations = {
.open = nonseekable_open,
.read = proc_fdinfo_read,
static const struct file_operations proc_fdinfo_file_operations = {
.open = nonseekable_open,
.read = proc_fdinfo_read,
};
static const struct file_operations proc_fd_operations = {
.read = generic_read_dir,
.readdir = proc_readfd,
};
static const struct file_operations proc_fd_operations = {
.read = generic_read_dir,
.readdir = proc_readfd,
+ .llseek = default_llseek,
static const struct file_operations proc_fdinfo_operations = {
.read = generic_read_dir,
.readdir = proc_readfdinfo,
static const struct file_operations proc_fdinfo_operations = {
.read = generic_read_dir,
.readdir = proc_readfdinfo,
+ .llseek = default_llseek,
static const struct file_operations proc_attr_dir_operations = {
.read = generic_read_dir,
.readdir = proc_attr_dir_readdir,
static const struct file_operations proc_attr_dir_operations = {
.read = generic_read_dir,
.readdir = proc_attr_dir_readdir,
+ .llseek = default_llseek,
};
static struct dentry *proc_attr_dir_lookup(struct inode *dir,
};
static struct dentry *proc_attr_dir_lookup(struct inode *dir,
static const struct file_operations proc_tgid_base_operations = {
.read = generic_read_dir,
.readdir = proc_tgid_base_readdir,
static const struct file_operations proc_tgid_base_operations = {
.read = generic_read_dir,
.readdir = proc_tgid_base_readdir,
+ .llseek = default_llseek,
};
static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
};
static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
static const struct file_operations proc_tid_base_operations = {
.read = generic_read_dir,
.readdir = proc_tid_base_readdir,
static const struct file_operations proc_tid_base_operations = {
.read = generic_read_dir,
.readdir = proc_tid_base_readdir,
+ .llseek = default_llseek,
};
static const struct inode_operations proc_tid_base_inode_operations = {
};
static const struct inode_operations proc_tid_base_inode_operations = {
static const struct file_operations proc_task_operations = {
.read = generic_read_dir,
.readdir = proc_task_readdir,
static const struct file_operations proc_task_operations = {
.read = generic_read_dir,
.readdir = proc_task_readdir,
+ .llseek = default_llseek,
static const struct file_operations proc_sys_file_operations = {
.read = proc_sys_read,
.write = proc_sys_write,
static const struct file_operations proc_sys_file_operations = {
.read = proc_sys_read,
.write = proc_sys_write,
+ .llseek = default_llseek,
};
static const struct file_operations proc_sys_dir_file_operations = {
};
static const struct file_operations proc_sys_dir_file_operations = {
static const struct file_operations proc_root_operations = {
.read = generic_read_dir,
.readdir = proc_root_readdir,
static const struct file_operations proc_root_operations = {
.read = generic_read_dir,
.readdir = proc_root_readdir,
+ .llseek = default_llseek,
const struct file_operations proc_clear_refs_operations = {
.write = clear_refs_write,
const struct file_operations proc_clear_refs_operations = {
.write = clear_refs_write,
static const struct file_operations romfs_dir_operations = {
.read = generic_read_dir,
.readdir = romfs_readdir,
static const struct file_operations romfs_dir_operations = {
.read = generic_read_dir,
.readdir = romfs_readdir,
+ .llseek = default_llseek,
};
static const struct inode_operations romfs_dir_inode_operations = {
};
static const struct inode_operations romfs_dir_inode_operations = {
.release = signalfd_release,
.poll = signalfd_poll,
.read = signalfd_read,
.release = signalfd_release,
.poll = signalfd_poll,
.read = signalfd_read,
};
SYSCALL_DEFINE4(signalfd4, int, ufd, sigset_t __user *, user_mask,
};
SYSCALL_DEFINE4(signalfd4, int, ufd, sigset_t __user *, user_mask,
const struct file_operations squashfs_dir_ops = {
.read = generic_read_dir,
const struct file_operations squashfs_dir_ops = {
.read = generic_read_dir,
- .readdir = squashfs_readdir
+ .readdir = squashfs_readdir,
+ .llseek = default_llseek,
.release = timerfd_release,
.poll = timerfd_poll,
.read = timerfd_read,
.release = timerfd_release,
.poll = timerfd_poll,
.read = timerfd_read,
};
static struct file *timerfd_fget(int fd)
};
static struct file *timerfd_fget(int fd)
.open = open_debugfs_file,
.write = write_debugfs_file,
.owner = THIS_MODULE,
.open = open_debugfs_file,
.write = write_debugfs_file,
.owner = THIS_MODULE,
+ .llseek = default_llseek,
.flush = mqueue_flush_file,
.poll = mqueue_poll_file,
.read = mqueue_read_file,
.flush = mqueue_flush_file,
.poll = mqueue_poll_file,
.read = mqueue_read_file,
+ .llseek = default_llseek,
};
static const struct super_operations mqueue_super_ops = {
};
static const struct super_operations mqueue_super_ops = {
#ifndef CONFIG_MMU
.get_unmapped_area = shm_get_unmapped_area,
#endif
#ifndef CONFIG_MMU
.get_unmapped_area = shm_get_unmapped_area,
#endif
};
static const struct file_operations shm_file_operations_huge = {
};
static const struct file_operations shm_file_operations_huge = {
.fsync = shm_fsync,
.release = shm_release,
.get_unmapped_area = shm_get_unmapped_area,
.fsync = shm_fsync,
.release = shm_release,
.get_unmapped_area = shm_get_unmapped_area,
};
int is_file_shm_hugepages(struct file *file)
};
int is_file_shm_hugepages(struct file *file)
static const struct file_operations ikconfig_file_ops = {
.owner = THIS_MODULE,
.read = ikconfig_read_current,
static const struct file_operations ikconfig_file_ops = {
.owner = THIS_MODULE,
.read = ikconfig_read_current,
+ .llseek = default_llseek,
};
static int __init ikconfig_init(void)
};
static int __init ikconfig_init(void)
static const struct file_operations gcov_reset_fops = {
.write = reset_write,
.read = reset_read,
static const struct file_operations gcov_reset_fops = {
.write = reset_write,
.read = reset_read,
static const struct file_operations fops_kp = {
.read = read_enabled_file_bool,
.write = write_enabled_file_bool,
static const struct file_operations fops_kp = {
.read = read_enabled_file_bool,
.write = write_enabled_file_bool,
+ .llseek = default_llseek,
};
static int __kprobes debugfs_kprobe_init(void)
};
static int __kprobes debugfs_kprobe_init(void)
.write = pm_qos_power_write,
.open = pm_qos_power_open,
.release = pm_qos_power_release,
.write = pm_qos_power_write,
.open = pm_qos_power_open,
.release = pm_qos_power_release,
};
/* unlocked internal variant */
};
/* unlocked internal variant */
static const struct file_operations proc_profile_operations = {
.read = read_profile,
.write = write_profile,
static const struct file_operations proc_profile_operations = {
.read = read_profile,
.write = write_profile,
+ .llseek = default_llseek,
.owner = THIS_MODULE,
.open = blk_dropped_open,
.read = blk_dropped_read,
.owner = THIS_MODULE,
.open = blk_dropped_open,
.read = blk_dropped_read,
+ .llseek = default_llseek,
};
static int blk_msg_open(struct inode *inode, struct file *filp)
};
static int blk_msg_open(struct inode *inode, struct file *filp)
.owner = THIS_MODULE,
.open = blk_msg_open,
.write = blk_msg_write,
.owner = THIS_MODULE,
.open = blk_msg_open,
.write = blk_msg_write,
.open = tracing_open_generic,
.read = ftrace_profile_read,
.write = ftrace_profile_write,
.open = tracing_open_generic,
.read = ftrace_profile_read,
.write = ftrace_profile_write,
+ .llseek = default_llseek,
};
/* used to initialize the real stat files */
};
/* used to initialize the real stat files */
.read = seq_read,
.write = ftrace_graph_write,
.release = ftrace_graph_release,
.read = seq_read,
.write = ftrace_graph_write,
.release = ftrace_graph_release,
};
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
};
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
.open = tracing_open_generic,
.read = rb_simple_read,
.write = rb_simple_write,
.open = tracing_open_generic,
.read = rb_simple_read,
.write = rb_simple_write,
+ .llseek = default_llseek,
.open = tracing_open_generic,
.read = event_enable_read,
.write = event_enable_write,
.open = tracing_open_generic,
.read = event_enable_read,
.write = event_enable_write,
+ .llseek = default_llseek,
};
static const struct file_operations ftrace_event_format_fops = {
};
static const struct file_operations ftrace_event_format_fops = {
static const struct file_operations ftrace_event_id_fops = {
.open = tracing_open_generic,
.read = event_id_read,
static const struct file_operations ftrace_event_id_fops = {
.open = tracing_open_generic,
.read = event_id_read,
+ .llseek = default_llseek,
};
static const struct file_operations ftrace_event_filter_fops = {
.open = tracing_open_generic,
.read = event_filter_read,
.write = event_filter_write,
};
static const struct file_operations ftrace_event_filter_fops = {
.open = tracing_open_generic,
.read = event_filter_read,
.write = event_filter_write,
+ .llseek = default_llseek,
};
static const struct file_operations ftrace_subsystem_filter_fops = {
.open = tracing_open_generic,
.read = subsystem_filter_read,
.write = subsystem_filter_write,
};
static const struct file_operations ftrace_subsystem_filter_fops = {
.open = tracing_open_generic,
.read = subsystem_filter_read,
.write = subsystem_filter_write,
+ .llseek = default_llseek,
};
static const struct file_operations ftrace_system_enable_fops = {
.open = tracing_open_generic,
.read = system_enable_read,
.write = system_enable_write,
};
static const struct file_operations ftrace_system_enable_fops = {
.open = tracing_open_generic,
.read = system_enable_read,
.write = system_enable_write,
+ .llseek = default_llseek,
};
static const struct file_operations ftrace_show_header_fops = {
.open = tracing_open_generic,
.read = show_header,
};
static const struct file_operations ftrace_show_header_fops = {
.open = tracing_open_generic,
.read = show_header,
+ .llseek = default_llseek,
};
static struct dentry *event_trace_events_dir(void)
};
static struct dentry *event_trace_events_dir(void)
.open = tracing_open_generic,
.read = stack_max_size_read,
.write = stack_max_size_write,
.open = tracing_open_generic,
.read = stack_max_size_read,
.write = stack_max_size_write,
+ .llseek = default_llseek,
static const struct file_operations filter_fops = {
.read = filter_read,
.write = filter_write,
static const struct file_operations filter_fops = {
.read = filter_read,
.write = filter_write,
+ .llseek = default_llseek,
};
static int dma_debug_fs_init(void)
};
static int dma_debug_fs_init(void)
static const struct file_operations proc_atm_dev_ops = {
.owner = THIS_MODULE,
.read = proc_dev_atm_read,
static const struct file_operations proc_atm_dev_ops = {
.owner = THIS_MODULE,
.read = proc_dev_atm_read,
};
static void add_stats(struct seq_file *seq, const char *aal,
};
static void add_stats(struct seq_file *seq, const char *aal,
.owner = THIS_MODULE,
.open = dccpprobe_open,
.read = dccpprobe_read,
.owner = THIS_MODULE,
.open = dccpprobe_open,
.read = dccpprobe_read,
};
static __init int dccpprobe_init(void)
};
static __init int dccpprobe_init(void)
.owner = THIS_MODULE,
.open = tcpprobe_open,
.read = tcpprobe_read,
.owner = THIS_MODULE,
.open = tcpprobe_open,
.read = tcpprobe_read,
};
static __init int tcpprobe_init(void)
};
static __init int tcpprobe_init(void)
static const struct file_operations tsf_ops = {
.read = tsf_read,
.write = tsf_write,
static const struct file_operations tsf_ops = {
.read = tsf_read,
.write = tsf_write,
- .open = mac80211_open_file_generic
+ .open = mac80211_open_file_generic,
+ .llseek = default_llseek,
};
static ssize_t reset_write(struct file *file, const char __user *user_buf,
};
static ssize_t reset_write(struct file *file, const char __user *user_buf,
static const struct file_operations reset_ops = {
.write = reset_write,
.open = mac80211_open_file_generic,
static const struct file_operations reset_ops = {
.write = reset_write,
.open = mac80211_open_file_generic,
};
static ssize_t noack_read(struct file *file, char __user *user_buf,
};
static ssize_t noack_read(struct file *file, char __user *user_buf,
static const struct file_operations noack_ops = {
.read = noack_read,
.write = noack_write,
static const struct file_operations noack_ops = {
.read = noack_read,
.write = noack_write,
- .open = mac80211_open_file_generic
+ .open = mac80211_open_file_generic,
+ .llseek = default_llseek,
};
static ssize_t uapsd_queues_read(struct file *file, char __user *user_buf,
};
static ssize_t uapsd_queues_read(struct file *file, char __user *user_buf,
static const struct file_operations uapsd_queues_ops = {
.read = uapsd_queues_read,
.write = uapsd_queues_write,
static const struct file_operations uapsd_queues_ops = {
.read = uapsd_queues_read,
.write = uapsd_queues_write,
- .open = mac80211_open_file_generic
+ .open = mac80211_open_file_generic,
+ .llseek = default_llseek,
};
static ssize_t uapsd_max_sp_len_read(struct file *file, char __user *user_buf,
};
static ssize_t uapsd_max_sp_len_read(struct file *file, char __user *user_buf,
static const struct file_operations uapsd_max_sp_len_ops = {
.read = uapsd_max_sp_len_read,
.write = uapsd_max_sp_len_write,
static const struct file_operations uapsd_max_sp_len_ops = {
.read = uapsd_max_sp_len_read,
.write = uapsd_max_sp_len_write,
- .open = mac80211_open_file_generic
+ .open = mac80211_open_file_generic,
+ .llseek = default_llseek,
};
static ssize_t channel_type_read(struct file *file, char __user *user_buf,
};
static ssize_t channel_type_read(struct file *file, char __user *user_buf,
static const struct file_operations channel_type_ops = {
.read = channel_type_read,
static const struct file_operations channel_type_ops = {
.read = channel_type_read,
- .open = mac80211_open_file_generic
+ .open = mac80211_open_file_generic,
+ .llseek = default_llseek,
};
static ssize_t queues_read(struct file *file, char __user *user_buf,
};
static ssize_t queues_read(struct file *file, char __user *user_buf,
static const struct file_operations queues_ops = {
.read = queues_read,
static const struct file_operations queues_ops = {
.read = queues_read,
- .open = mac80211_open_file_generic
+ .open = mac80211_open_file_generic,
+ .llseek = default_llseek,
};
/* statistics stuff */
};
/* statistics stuff */
static const struct file_operations rcname_ops = {
.read = rcname_read,
.open = mac80211_open_file_generic,
static const struct file_operations rcname_ops = {
.read = rcname_read,
.open = mac80211_open_file_generic,
+ .llseek = default_llseek,
.open = minstrel_stats_open,
.read = minstrel_stats_read,
.release = minstrel_stats_release,
.open = minstrel_stats_open,
.read = minstrel_stats_read,
.release = minstrel_stats_release,
+ .llseek = default_llseek,
.poll = rate_control_pid_events_poll,
.open = rate_control_pid_events_open,
.release = rate_control_pid_events_release,
.poll = rate_control_pid_events_poll,
.open = rate_control_pid_events_open,
.release = rate_control_pid_events_release,
};
void rate_control_pid_add_sta_debugfs(void *priv, void *priv_sta,
};
void rate_control_pid_add_sta_debugfs(void *priv, void *priv_sta,
.write = recent_mt_proc_write,
.release = seq_release_private,
.owner = THIS_MODULE,
.write = recent_mt_proc_write,
.release = seq_release_private,
.owner = THIS_MODULE,
};
static int __net_init recent_proc_net_init(struct net *net)
};
static int __net_init recent_proc_net_init(struct net *net)
const struct file_operations bad_sock_fops = {
.owner = THIS_MODULE,
.open = sock_no_open,
const struct file_operations bad_sock_fops = {
.owner = THIS_MODULE,
.open = sock_no_open,
.unlocked_ioctl = rfkill_fop_ioctl,
.compat_ioctl = rfkill_fop_ioctl,
#endif
.unlocked_ioctl = rfkill_fop_ioctl,
.compat_ioctl = rfkill_fop_ioctl,
#endif
};
static struct miscdevice rfkill_miscdev = {
};
static struct miscdevice rfkill_miscdev = {
.owner = THIS_MODULE,
.open = sctpprobe_open,
.read = sctpprobe_read,
.owner = THIS_MODULE,
.open = sctpprobe_open,
.read = sctpprobe_read,
};
sctp_disposition_t jsctp_sf_eat_sack(const struct sctp_endpoint *ep,
};
sctp_disposition_t jsctp_sf_eat_sack(const struct sctp_endpoint *ep,
const struct file_operations bad_sock_fops = {
.owner = THIS_MODULE,
.open = sock_no_open,
const struct file_operations bad_sock_fops = {
.owner = THIS_MODULE,
.open = sock_no_open,
.read = read_flush_procfs,
.write = write_flush_procfs,
.release = release_flush_procfs,
.read = read_flush_procfs,
.write = write_flush_procfs,
.release = release_flush_procfs,
};
static void remove_cache_proc_entries(struct cache_detail *cd)
};
static void remove_cache_proc_entries(struct cache_detail *cd)
.read = read_flush_pipefs,
.write = write_flush_pipefs,
.release = release_flush_pipefs,
.read = read_flush_pipefs,
.write = write_flush_pipefs,
.release = release_flush_pipefs,
};
int sunrpc_cache_register_pipefs(struct dentry *parent,
};
int sunrpc_cache_register_pipefs(struct dentry *parent,
static const struct file_operations ht40allow_map_ops = {
.read = ht40allow_map_read,
.open = cfg80211_open_file_generic,
static const struct file_operations ht40allow_map_ops = {
.read = ht40allow_map_read,
.open = cfg80211_open_file_generic,
+ .llseek = default_llseek,
};
#define DEBUGFS_ADD(name) \
};
#define DEBUGFS_ADD(name) \
.owner = THIS_MODULE,
.read = fifo_read,
.write = fifo_write,
.owner = THIS_MODULE,
.read = fifo_read,
.write = fifo_write,
};
static int __init example_init(void)
};
static int __init example_init(void)
.owner = THIS_MODULE,
.read = fifo_read,
.write = fifo_write,
.owner = THIS_MODULE,
.read = fifo_read,
.write = fifo_write,
};
static int __init example_init(void)
};
static int __init example_init(void)
.owner = THIS_MODULE,
.read = fifo_read,
.write = fifo_write,
.owner = THIS_MODULE,
.read = fifo_read,
.write = fifo_write,
};
static int __init example_init(void)
};
static int __init example_init(void)
static const struct file_operations mark_ops = {
.open = my_open,
static const struct file_operations mark_ops = {
.open = my_open,
};
static int __init sample_init(void)
};
static int __init sample_init(void)
}
static const struct file_operations aa_fs_profile_load = {
}
static const struct file_operations aa_fs_profile_load = {
+ .write = profile_load,
+ .llseek = default_llseek,
};
/* .replace file hook fn to load and/or replace policy */
};
/* .replace file hook fn to load and/or replace policy */
}
static const struct file_operations aa_fs_profile_replace = {
}
static const struct file_operations aa_fs_profile_replace = {
- .write = profile_replace
+ .write = profile_replace,
+ .llseek = default_llseek,
};
/* .remove file hook fn to remove loaded policy */
};
/* .remove file hook fn to remove loaded policy */
}
static const struct file_operations aa_fs_profile_remove = {
}
static const struct file_operations aa_fs_profile_remove = {
- .write = profile_remove
+ .write = profile_remove,
+ .llseek = default_llseek,
};
/** Base file system setup **/
};
/** Base file system setup **/
.read = default_read_file,
.write = default_write_file,
.open = default_open,
.read = default_read_file,
.write = default_write_file,
.open = default_open,
};
static struct inode *get_inode(struct super_block *sb, int mode, dev_t dev)
};
static struct inode *get_inode(struct super_block *sb, int mode, dev_t dev)
static const struct file_operations smk_doi_ops = {
.read = smk_read_doi,
.write = smk_write_doi,
static const struct file_operations smk_doi_ops = {
.read = smk_read_doi,
.write = smk_write_doi,
+ .llseek = default_llseek,
static const struct file_operations smk_direct_ops = {
.read = smk_read_direct,
.write = smk_write_direct,
static const struct file_operations smk_direct_ops = {
.read = smk_read_direct,
.write = smk_write_direct,
+ .llseek = default_llseek,
static const struct file_operations smk_ambient_ops = {
.read = smk_read_ambient,
.write = smk_write_ambient,
static const struct file_operations smk_ambient_ops = {
.read = smk_read_ambient,
.write = smk_write_ambient,
+ .llseek = default_llseek,
static const struct file_operations smk_onlycap_ops = {
.read = smk_read_onlycap,
.write = smk_write_onlycap,
static const struct file_operations smk_onlycap_ops = {
.read = smk_read_onlycap,
.write = smk_write_onlycap,
+ .llseek = default_llseek,
static const struct file_operations smk_logging_ops = {
.read = smk_read_logging,
.write = smk_write_logging,
static const struct file_operations smk_logging_ops = {
.read = smk_read_logging,
.write = smk_write_logging,
+ .llseek = default_llseek,
};
/**
* smk_fill_super - fill the /smackfs superblock
};
/**
* smk_fill_super - fill the /smackfs superblock
.poll = odev_poll,
.unlocked_ioctl = odev_ioctl,
.compat_ioctl = odev_ioctl_compat,
.poll = odev_poll,
.unlocked_ioctl = odev_ioctl,
.compat_ioctl = odev_ioctl_compat,
static const struct file_operations snd_fops =
{
.owner = THIS_MODULE,
static const struct file_operations snd_fops =
{
.owner = THIS_MODULE,
+ .open = snd_open,
+ .llseek = noop_llseek,
};
#ifdef CONFIG_SND_DYNAMIC_MINORS
};
#ifdef CONFIG_SND_DYNAMIC_MINORS
.unlocked_ioctl = dev_ioctl,
.open = dev_open,
.release = dev_release,
.unlocked_ioctl = dev_ioctl,
.open = dev_open,
.release = dev_release,
};
static int reset_dsp(void)
};
static int reset_dsp(void)
.open = codec_reg_open_file,
.read = codec_reg_read_file,
.write = codec_reg_write_file,
.open = codec_reg_open_file,
.read = codec_reg_read_file,
.write = codec_reg_write_file,
+ .llseek = default_llseek,
};
static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
};
static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
static const struct file_operations dapm_widget_power_fops = {
.open = dapm_widget_power_open_file,
.read = dapm_widget_power_read_file,
static const struct file_operations dapm_widget_power_fops = {
.open = dapm_widget_power_open_file,
.read = dapm_widget_power_read_file,
+ .llseek = default_llseek,
};
void snd_soc_dapm_debugfs_init(struct snd_soc_codec *codec)
};
void snd_soc_dapm_debugfs_init(struct snd_soc_codec *codec)
/* We must have an owner or the module locking fails */
.owner = THIS_MODULE,
.open = soundcore_open,
/* We must have an owner or the module locking fails */
.owner = THIS_MODULE,
.open = soundcore_open,
.unlocked_ioctl = kvm_vcpu_ioctl,
.compat_ioctl = kvm_vcpu_ioctl,
.mmap = kvm_vcpu_mmap,
.unlocked_ioctl = kvm_vcpu_ioctl,
.compat_ioctl = kvm_vcpu_ioctl,
.mmap = kvm_vcpu_mmap,
.compat_ioctl = kvm_vm_compat_ioctl,
#endif
.mmap = kvm_vm_mmap,
.compat_ioctl = kvm_vm_compat_ioctl,
#endif
.mmap = kvm_vm_mmap,
};
static int kvm_dev_ioctl_create_vm(void)
};
static int kvm_dev_ioctl_create_vm(void)
static struct file_operations kvm_chardev_ops = {
.unlocked_ioctl = kvm_dev_ioctl,
.compat_ioctl = kvm_dev_ioctl,
static struct file_operations kvm_chardev_ops = {
.unlocked_ioctl = kvm_dev_ioctl,
.compat_ioctl = kvm_dev_ioctl,
};
static struct miscdevice kvm_dev = {
};
static struct miscdevice kvm_dev = {
projects / linux.git / commitdiff