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>
41 #include "ipath_kernel.h"
43 #define IPATHFS_MAGIC 0x726a77
45 static struct super_block
*ipath_super
;
47 static int ipathfs_mknod(struct inode
*dir
, struct dentry
*dentry
,
48 int mode
, const struct file_operations
*fops
,
52 struct inode
*inode
= new_inode(dir
->i_sb
);
60 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
61 inode
->i_private
= data
;
62 if ((mode
& S_IFMT
) == S_IFDIR
) {
63 inode
->i_op
= &simple_dir_inode_operations
;
70 d_instantiate(dentry
, inode
);
77 static int create_file(const char *name
, mode_t mode
,
78 struct dentry
*parent
, struct dentry
**dentry
,
79 const struct file_operations
*fops
, void *data
)
84 mutex_lock(&parent
->d_inode
->i_mutex
);
85 *dentry
= lookup_one_len(name
, parent
, strlen(name
));
87 error
= ipathfs_mknod(parent
->d_inode
, *dentry
,
90 error
= PTR_ERR(dentry
);
91 mutex_unlock(&parent
->d_inode
->i_mutex
);
96 static ssize_t
atomic_stats_read(struct file
*file
, char __user
*buf
,
97 size_t count
, loff_t
*ppos
)
99 return simple_read_from_buffer(buf
, count
, ppos
, &ipath_stats
,
103 static const struct file_operations atomic_stats_ops
= {
104 .read
= atomic_stats_read
,
107 static ssize_t
atomic_counters_read(struct file
*file
, char __user
*buf
,
108 size_t count
, loff_t
*ppos
)
110 struct infinipath_counters counters
;
111 struct ipath_devdata
*dd
;
113 dd
= file
->f_path
.dentry
->d_inode
->i_private
;
114 dd
->ipath_f_read_counters(dd
, &counters
);
116 return simple_read_from_buffer(buf
, count
, ppos
, &counters
,
120 static const struct file_operations atomic_counters_ops
= {
121 .read
= atomic_counters_read
,
124 static ssize_t
flash_read(struct file
*file
, char __user
*buf
,
125 size_t count
, loff_t
*ppos
)
127 struct ipath_devdata
*dd
;
139 if (pos
>= sizeof(struct ipath_flash
)) {
144 if (count
> sizeof(struct ipath_flash
) - pos
)
145 count
= sizeof(struct ipath_flash
) - pos
;
147 tmp
= kmalloc(count
, GFP_KERNEL
);
153 dd
= file
->f_path
.dentry
->d_inode
->i_private
;
154 if (ipath_eeprom_read(dd
, pos
, tmp
, count
)) {
155 ipath_dev_err(dd
, "failed to read from flash\n");
160 if (copy_to_user(buf
, tmp
, count
)) {
175 static ssize_t
flash_write(struct file
*file
, const char __user
*buf
,
176 size_t count
, loff_t
*ppos
)
178 struct ipath_devdata
*dd
;
190 if (count
!= sizeof(struct ipath_flash
)) {
195 tmp
= kmalloc(count
, GFP_KERNEL
);
201 if (copy_from_user(tmp
, buf
, count
)) {
206 dd
= file
->f_path
.dentry
->d_inode
->i_private
;
207 if (ipath_eeprom_write(dd
, pos
, tmp
, count
)) {
209 ipath_dev_err(dd
, "failed to write to flash\n");
223 static const struct file_operations flash_ops
= {
225 .write
= flash_write
,
228 static int create_device_files(struct super_block
*sb
,
229 struct ipath_devdata
*dd
)
231 struct dentry
*dir
, *tmp
;
235 snprintf(unit
, sizeof unit
, "%02d", dd
->ipath_unit
);
236 ret
= create_file(unit
, S_IFDIR
|S_IRUGO
|S_IXUGO
, sb
->s_root
, &dir
,
237 &simple_dir_operations
, dd
);
239 printk(KERN_ERR
"create_file(%s) failed: %d\n", unit
, ret
);
243 ret
= create_file("atomic_counters", S_IFREG
|S_IRUGO
, dir
, &tmp
,
244 &atomic_counters_ops
, dd
);
246 printk(KERN_ERR
"create_file(%s/atomic_counters) "
247 "failed: %d\n", unit
, ret
);
251 ret
= create_file("flash", S_IFREG
|S_IWUSR
|S_IRUGO
, dir
, &tmp
,
254 printk(KERN_ERR
"create_file(%s/flash) "
255 "failed: %d\n", unit
, ret
);
263 static int remove_file(struct dentry
*parent
, char *name
)
268 tmp
= lookup_one_len(name
, parent
, strlen(name
));
275 spin_lock(&dcache_lock
);
276 spin_lock(&tmp
->d_lock
);
277 if (!(d_unhashed(tmp
) && tmp
->d_inode
)) {
280 spin_unlock(&tmp
->d_lock
);
281 spin_unlock(&dcache_lock
);
282 simple_unlink(parent
->d_inode
, tmp
);
284 spin_unlock(&tmp
->d_lock
);
285 spin_unlock(&dcache_lock
);
291 * We don't expect clients to care about the return value, but
292 * it's there if they need it.
297 static int remove_device_files(struct super_block
*sb
,
298 struct ipath_devdata
*dd
)
300 struct dentry
*dir
, *root
;
304 root
= dget(sb
->s_root
);
305 mutex_lock(&root
->d_inode
->i_mutex
);
306 snprintf(unit
, sizeof unit
, "%02d", dd
->ipath_unit
);
307 dir
= lookup_one_len(unit
, root
, strlen(unit
));
311 printk(KERN_ERR
"Lookup of %s failed\n", unit
);
315 remove_file(dir
, "flash");
316 remove_file(dir
, "atomic_counters");
318 ret
= simple_rmdir(root
->d_inode
, dir
);
321 mutex_unlock(&root
->d_inode
->i_mutex
);
326 static int ipathfs_fill_super(struct super_block
*sb
, void *data
,
329 struct ipath_devdata
*dd
, *tmp
;
333 static struct tree_descr files
[] = {
334 [2] = {"atomic_stats", &atomic_stats_ops
, S_IRUGO
},
338 ret
= simple_fill_super(sb
, IPATHFS_MAGIC
, files
);
340 printk(KERN_ERR
"simple_fill_super failed: %d\n", ret
);
344 spin_lock_irqsave(&ipath_devs_lock
, flags
);
346 list_for_each_entry_safe(dd
, tmp
, &ipath_dev_list
, ipath_list
) {
347 spin_unlock_irqrestore(&ipath_devs_lock
, flags
);
348 ret
= create_device_files(sb
, dd
);
350 deactivate_locked_super(sb
);
353 spin_lock_irqsave(&ipath_devs_lock
, flags
);
356 spin_unlock_irqrestore(&ipath_devs_lock
, flags
);
362 static int ipathfs_get_sb(struct file_system_type
*fs_type
, int flags
,
363 const char *dev_name
, void *data
, struct vfsmount
*mnt
)
365 int ret
= get_sb_single(fs_type
, flags
, data
,
366 ipathfs_fill_super
, mnt
);
368 ipath_super
= mnt
->mnt_sb
;
372 static void ipathfs_kill_super(struct super_block
*s
)
374 kill_litter_super(s
);
378 int ipathfs_add_device(struct ipath_devdata
*dd
)
382 if (ipath_super
== NULL
) {
387 ret
= create_device_files(ipath_super
, dd
);
393 int ipathfs_remove_device(struct ipath_devdata
*dd
)
397 if (ipath_super
== NULL
) {
402 ret
= remove_device_files(ipath_super
, dd
);
408 static struct file_system_type ipathfs_fs_type
= {
409 .owner
= THIS_MODULE
,
411 .get_sb
= ipathfs_get_sb
,
412 .kill_sb
= ipathfs_kill_super
,
415 int __init
ipath_init_ipathfs(void)
417 return register_filesystem(&ipathfs_fs_type
);
420 void __exit
ipath_exit_ipathfs(void)
422 unregister_filesystem(&ipathfs_fs_type
);