2 * Copyright (c) 2006, 2007 QLogic Corporation. All rights reserved.
3 * Copyright (c) 2006 PathScale, Inc. All rights reserved.
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
34 #include <linux/module.h>
36 #include <linux/mount.h>
37 #include <linux/pagemap.h>
38 #include <linux/init.h>
39 #include <linux/namei.h>
40 #include <linux/slab.h>
42 #include "ipath_kernel.h"
44 #define IPATHFS_MAGIC 0x726a77
46 static struct super_block
*ipath_super
;
48 static int ipathfs_mknod(struct inode
*dir
, struct dentry
*dentry
,
49 umode_t mode
, const struct file_operations
*fops
,
53 struct inode
*inode
= new_inode(dir
->i_sb
);
60 inode
->i_ino
= get_next_ino();
62 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
63 inode
->i_private
= data
;
65 inode
->i_op
= &simple_dir_inode_operations
;
72 d_instantiate(dentry
, inode
);
79 static int create_file(const char *name
, umode_t mode
,
80 struct dentry
*parent
, struct dentry
**dentry
,
81 const struct file_operations
*fops
, void *data
)
85 inode_lock(d_inode(parent
));
86 *dentry
= lookup_one_len(name
, parent
, strlen(name
));
88 error
= ipathfs_mknod(d_inode(parent
), *dentry
,
91 error
= PTR_ERR(*dentry
);
92 inode_unlock(d_inode(parent
));
97 static ssize_t
atomic_stats_read(struct file
*file
, char __user
*buf
,
98 size_t count
, loff_t
*ppos
)
100 return simple_read_from_buffer(buf
, count
, ppos
, &ipath_stats
,
104 static const struct file_operations atomic_stats_ops
= {
105 .read
= atomic_stats_read
,
106 .llseek
= default_llseek
,
109 static ssize_t
atomic_counters_read(struct file
*file
, char __user
*buf
,
110 size_t count
, loff_t
*ppos
)
112 struct infinipath_counters counters
;
113 struct ipath_devdata
*dd
;
115 dd
= file_inode(file
)->i_private
;
116 dd
->ipath_f_read_counters(dd
, &counters
);
118 return simple_read_from_buffer(buf
, count
, ppos
, &counters
,
122 static const struct file_operations atomic_counters_ops
= {
123 .read
= atomic_counters_read
,
124 .llseek
= default_llseek
,
127 static ssize_t
flash_read(struct file
*file
, char __user
*buf
,
128 size_t count
, loff_t
*ppos
)
130 struct ipath_devdata
*dd
;
142 if (pos
>= sizeof(struct ipath_flash
)) {
147 if (count
> sizeof(struct ipath_flash
) - pos
)
148 count
= sizeof(struct ipath_flash
) - pos
;
150 tmp
= kmalloc(count
, GFP_KERNEL
);
156 dd
= file_inode(file
)->i_private
;
157 if (ipath_eeprom_read(dd
, pos
, tmp
, count
)) {
158 ipath_dev_err(dd
, "failed to read from flash\n");
163 if (copy_to_user(buf
, tmp
, count
)) {
178 static ssize_t
flash_write(struct file
*file
, const char __user
*buf
,
179 size_t count
, loff_t
*ppos
)
181 struct ipath_devdata
*dd
;
193 if (count
!= sizeof(struct ipath_flash
)) {
198 tmp
= memdup_user(buf
, count
);
202 dd
= file_inode(file
)->i_private
;
203 if (ipath_eeprom_write(dd
, pos
, tmp
, count
)) {
205 ipath_dev_err(dd
, "failed to write to flash\n");
219 static const struct file_operations flash_ops
= {
221 .write
= flash_write
,
222 .llseek
= default_llseek
,
225 static int create_device_files(struct super_block
*sb
,
226 struct ipath_devdata
*dd
)
228 struct dentry
*dir
, *tmp
;
232 snprintf(unit
, sizeof unit
, "%02d", dd
->ipath_unit
);
233 ret
= create_file(unit
, S_IFDIR
|S_IRUGO
|S_IXUGO
, sb
->s_root
, &dir
,
234 &simple_dir_operations
, dd
);
236 printk(KERN_ERR
"create_file(%s) failed: %d\n", unit
, ret
);
240 ret
= create_file("atomic_counters", S_IFREG
|S_IRUGO
, dir
, &tmp
,
241 &atomic_counters_ops
, dd
);
243 printk(KERN_ERR
"create_file(%s/atomic_counters) "
244 "failed: %d\n", unit
, ret
);
248 ret
= create_file("flash", S_IFREG
|S_IWUSR
|S_IRUGO
, dir
, &tmp
,
251 printk(KERN_ERR
"create_file(%s/flash) "
252 "failed: %d\n", unit
, ret
);
260 static int remove_file(struct dentry
*parent
, char *name
)
265 tmp
= lookup_one_len(name
, parent
, strlen(name
));
272 spin_lock(&tmp
->d_lock
);
273 if (simple_positive(tmp
)) {
276 spin_unlock(&tmp
->d_lock
);
277 simple_unlink(d_inode(parent
), tmp
);
279 spin_unlock(&tmp
->d_lock
);
284 * We don't expect clients to care about the return value, but
285 * it's there if they need it.
290 static int remove_device_files(struct super_block
*sb
,
291 struct ipath_devdata
*dd
)
293 struct dentry
*dir
, *root
;
297 root
= dget(sb
->s_root
);
298 inode_lock(d_inode(root
));
299 snprintf(unit
, sizeof unit
, "%02d", dd
->ipath_unit
);
300 dir
= lookup_one_len(unit
, root
, strlen(unit
));
304 printk(KERN_ERR
"Lookup of %s failed\n", unit
);
308 remove_file(dir
, "flash");
309 remove_file(dir
, "atomic_counters");
311 ret
= simple_rmdir(d_inode(root
), dir
);
314 inode_unlock(d_inode(root
));
319 static int ipathfs_fill_super(struct super_block
*sb
, void *data
,
322 struct ipath_devdata
*dd
, *tmp
;
326 static struct tree_descr files
[] = {
327 [2] = {"atomic_stats", &atomic_stats_ops
, S_IRUGO
},
331 ret
= simple_fill_super(sb
, IPATHFS_MAGIC
, files
);
333 printk(KERN_ERR
"simple_fill_super failed: %d\n", ret
);
337 spin_lock_irqsave(&ipath_devs_lock
, flags
);
339 list_for_each_entry_safe(dd
, tmp
, &ipath_dev_list
, ipath_list
) {
340 spin_unlock_irqrestore(&ipath_devs_lock
, flags
);
341 ret
= create_device_files(sb
, dd
);
344 spin_lock_irqsave(&ipath_devs_lock
, flags
);
347 spin_unlock_irqrestore(&ipath_devs_lock
, flags
);
353 static struct dentry
*ipathfs_mount(struct file_system_type
*fs_type
,
354 int flags
, const char *dev_name
, void *data
)
357 ret
= mount_single(fs_type
, flags
, data
, ipathfs_fill_super
);
359 ipath_super
= ret
->d_sb
;
363 static void ipathfs_kill_super(struct super_block
*s
)
365 kill_litter_super(s
);
369 int ipathfs_add_device(struct ipath_devdata
*dd
)
373 if (ipath_super
== NULL
) {
378 ret
= create_device_files(ipath_super
, dd
);
384 int ipathfs_remove_device(struct ipath_devdata
*dd
)
388 if (ipath_super
== NULL
) {
393 ret
= remove_device_files(ipath_super
, dd
);
399 static struct file_system_type ipathfs_fs_type
= {
400 .owner
= THIS_MODULE
,
402 .mount
= ipathfs_mount
,
403 .kill_sb
= ipathfs_kill_super
,
405 MODULE_ALIAS_FS("ipathfs");
407 int __init
ipath_init_ipathfs(void)
409 return register_filesystem(&ipathfs_fs_type
);
412 void __exit
ipath_exit_ipathfs(void)
414 unregister_filesystem(&ipathfs_fs_type
);