5 * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
7 * Author: Arnd Bergmann <arndb@de.ibm.com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2, or (at your option)
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #include <linux/file.h>
26 #include <linux/fsnotify.h>
27 #include <linux/backing-dev.h>
28 #include <linux/init.h>
29 #include <linux/ioctl.h>
30 #include <linux/module.h>
31 #include <linux/mount.h>
32 #include <linux/namei.h>
33 #include <linux/pagemap.h>
34 #include <linux/poll.h>
35 #include <linux/slab.h>
36 #include <linux/parser.h>
40 #include <asm/spu_priv1.h>
41 #include <asm/uaccess.h>
45 struct spufs_sb_info
{
49 static struct kmem_cache
*spufs_inode_cache
;
50 char *isolated_loader
;
51 static int isolated_loader_size
;
53 static struct spufs_sb_info
*spufs_get_sb_info(struct super_block
*sb
)
59 spufs_alloc_inode(struct super_block
*sb
)
61 struct spufs_inode_info
*ei
;
63 ei
= kmem_cache_alloc(spufs_inode_cache
, GFP_KERNEL
);
71 return &ei
->vfs_inode
;
74 static void spufs_i_callback(struct rcu_head
*head
)
76 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
77 kmem_cache_free(spufs_inode_cache
, SPUFS_I(inode
));
80 static void spufs_destroy_inode(struct inode
*inode
)
82 call_rcu(&inode
->i_rcu
, spufs_i_callback
);
86 spufs_init_once(void *p
)
88 struct spufs_inode_info
*ei
= p
;
90 inode_init_once(&ei
->vfs_inode
);
94 spufs_new_inode(struct super_block
*sb
, umode_t mode
)
98 inode
= new_inode(sb
);
102 inode
->i_mode
= mode
;
103 inode
->i_uid
= current_fsuid();
104 inode
->i_gid
= current_fsgid();
105 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
111 spufs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
113 struct inode
*inode
= dentry
->d_inode
;
115 if ((attr
->ia_valid
& ATTR_SIZE
) &&
116 (attr
->ia_size
!= inode
->i_size
))
118 setattr_copy(inode
, attr
);
119 mark_inode_dirty(inode
);
125 spufs_new_file(struct super_block
*sb
, struct dentry
*dentry
,
126 const struct file_operations
*fops
, umode_t mode
,
127 size_t size
, struct spu_context
*ctx
)
129 static const struct inode_operations spufs_file_iops
= {
130 .setattr
= spufs_setattr
,
136 inode
= spufs_new_inode(sb
, S_IFREG
| mode
);
141 inode
->i_op
= &spufs_file_iops
;
143 inode
->i_size
= size
;
144 inode
->i_private
= SPUFS_I(inode
)->i_ctx
= get_spu_context(ctx
);
145 d_add(dentry
, inode
);
151 spufs_evict_inode(struct inode
*inode
)
153 struct spufs_inode_info
*ei
= SPUFS_I(inode
);
154 end_writeback(inode
);
156 put_spu_context(ei
->i_ctx
);
158 put_spu_gang(ei
->i_gang
);
161 static void spufs_prune_dir(struct dentry
*dir
)
163 struct dentry
*dentry
, *tmp
;
165 mutex_lock(&dir
->d_inode
->i_mutex
);
166 list_for_each_entry_safe(dentry
, tmp
, &dir
->d_subdirs
, d_u
.d_child
) {
167 spin_lock(&dentry
->d_lock
);
168 if (!(d_unhashed(dentry
)) && dentry
->d_inode
) {
171 spin_unlock(&dentry
->d_lock
);
172 simple_unlink(dir
->d_inode
, dentry
);
173 /* XXX: what was dcache_lock protecting here? Other
174 * filesystems (IB, configfs) release dcache_lock
178 spin_unlock(&dentry
->d_lock
);
181 shrink_dcache_parent(dir
);
182 mutex_unlock(&dir
->d_inode
->i_mutex
);
185 /* Caller must hold parent->i_mutex */
186 static int spufs_rmdir(struct inode
*parent
, struct dentry
*dir
)
188 /* remove all entries */
189 spufs_prune_dir(dir
);
192 return simple_rmdir(parent
, dir
);
195 static int spufs_fill_dir(struct dentry
*dir
,
196 const struct spufs_tree_descr
*files
, umode_t mode
,
197 struct spu_context
*ctx
)
199 struct dentry
*dentry
, *tmp
;
202 while (files
->name
&& files
->name
[0]) {
204 dentry
= d_alloc_name(dir
, files
->name
);
207 ret
= spufs_new_file(dir
->d_sb
, dentry
, files
->ops
,
208 files
->mode
& mode
, files
->size
, ctx
);
216 * remove all children from dir. dir->inode is not set so don't
217 * just simply use spufs_prune_dir() and panic afterwards :)
218 * dput() looks like it will do the right thing:
219 * - dec parent's ref counter
220 * - remove child from parent's child list
221 * - free child's inode if possible
224 list_for_each_entry_safe(dentry
, tmp
, &dir
->d_subdirs
, d_u
.d_child
) {
228 shrink_dcache_parent(dir
);
232 static int spufs_dir_close(struct inode
*inode
, struct file
*file
)
234 struct spu_context
*ctx
;
235 struct inode
*parent
;
239 dir
= file
->f_path
.dentry
;
240 parent
= dir
->d_parent
->d_inode
;
241 ctx
= SPUFS_I(dir
->d_inode
)->i_ctx
;
243 mutex_lock_nested(&parent
->i_mutex
, I_MUTEX_PARENT
);
244 ret
= spufs_rmdir(parent
, dir
);
245 mutex_unlock(&parent
->i_mutex
);
248 /* We have to give up the mm_struct */
251 return dcache_dir_close(inode
, file
);
254 const struct file_operations spufs_context_fops
= {
255 .open
= dcache_dir_open
,
256 .release
= spufs_dir_close
,
257 .llseek
= dcache_dir_lseek
,
258 .read
= generic_read_dir
,
259 .readdir
= dcache_readdir
,
262 EXPORT_SYMBOL_GPL(spufs_context_fops
);
265 spufs_mkdir(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
,
270 struct spu_context
*ctx
;
273 inode
= spufs_new_inode(dir
->i_sb
, mode
| S_IFDIR
);
277 if (dir
->i_mode
& S_ISGID
) {
278 inode
->i_gid
= dir
->i_gid
;
279 inode
->i_mode
&= S_ISGID
;
281 ctx
= alloc_spu_context(SPUFS_I(dir
)->i_gang
); /* XXX gang */
282 SPUFS_I(inode
)->i_ctx
= ctx
;
287 inode
->i_op
= &simple_dir_inode_operations
;
288 inode
->i_fop
= &simple_dir_operations
;
289 if (flags
& SPU_CREATE_NOSCHED
)
290 ret
= spufs_fill_dir(dentry
, spufs_dir_nosched_contents
,
293 ret
= spufs_fill_dir(dentry
, spufs_dir_contents
, mode
, ctx
);
298 if (spufs_get_sb_info(dir
->i_sb
)->debug
)
299 ret
= spufs_fill_dir(dentry
, spufs_dir_debug_contents
,
305 d_instantiate(dentry
, inode
);
308 inc_nlink(dentry
->d_inode
);
313 put_spu_context(ctx
);
320 static int spufs_context_open(struct dentry
*dentry
, struct vfsmount
*mnt
)
325 ret
= get_unused_fd();
332 filp
= dentry_open(dentry
, mnt
, O_RDONLY
, current_cred());
339 filp
->f_op
= &spufs_context_fops
;
340 fd_install(ret
, filp
);
345 static struct spu_context
*
346 spufs_assert_affinity(unsigned int flags
, struct spu_gang
*gang
,
349 struct spu_context
*tmp
, *neighbor
, *err
;
353 aff_supp
= !list_empty(&(list_entry(cbe_spu_info
[0].spus
.next
,
354 struct spu
, cbe_list
))->aff_list
);
357 return ERR_PTR(-EINVAL
);
359 if (flags
& SPU_CREATE_GANG
)
360 return ERR_PTR(-EINVAL
);
362 if (flags
& SPU_CREATE_AFFINITY_MEM
&&
364 gang
->aff_ref_ctx
->flags
& SPU_CREATE_AFFINITY_MEM
)
365 return ERR_PTR(-EEXIST
);
367 if (gang
->aff_flags
& AFF_MERGED
)
368 return ERR_PTR(-EBUSY
);
371 if (flags
& SPU_CREATE_AFFINITY_SPU
) {
372 if (!filp
|| filp
->f_op
!= &spufs_context_fops
)
373 return ERR_PTR(-EINVAL
);
375 neighbor
= get_spu_context(
376 SPUFS_I(filp
->f_dentry
->d_inode
)->i_ctx
);
378 if (!list_empty(&neighbor
->aff_list
) && !(neighbor
->aff_head
) &&
379 !list_is_last(&neighbor
->aff_list
, &gang
->aff_list_head
) &&
380 !list_entry(neighbor
->aff_list
.next
, struct spu_context
,
381 aff_list
)->aff_head
) {
382 err
= ERR_PTR(-EEXIST
);
383 goto out_put_neighbor
;
386 if (gang
!= neighbor
->gang
) {
387 err
= ERR_PTR(-EINVAL
);
388 goto out_put_neighbor
;
392 list_for_each_entry(tmp
, &gang
->aff_list_head
, aff_list
)
394 if (list_empty(&neighbor
->aff_list
))
397 for (node
= 0; node
< MAX_NUMNODES
; node
++) {
398 if ((cbe_spu_info
[node
].n_spus
- atomic_read(
399 &cbe_spu_info
[node
].reserved_spus
)) >= count
)
403 if (node
== MAX_NUMNODES
) {
404 err
= ERR_PTR(-EEXIST
);
405 goto out_put_neighbor
;
412 put_spu_context(neighbor
);
417 spufs_set_affinity(unsigned int flags
, struct spu_context
*ctx
,
418 struct spu_context
*neighbor
)
420 if (flags
& SPU_CREATE_AFFINITY_MEM
)
421 ctx
->gang
->aff_ref_ctx
= ctx
;
423 if (flags
& SPU_CREATE_AFFINITY_SPU
) {
424 if (list_empty(&neighbor
->aff_list
)) {
425 list_add_tail(&neighbor
->aff_list
,
426 &ctx
->gang
->aff_list_head
);
427 neighbor
->aff_head
= 1;
430 if (list_is_last(&neighbor
->aff_list
, &ctx
->gang
->aff_list_head
)
431 || list_entry(neighbor
->aff_list
.next
, struct spu_context
,
432 aff_list
)->aff_head
) {
433 list_add(&ctx
->aff_list
, &neighbor
->aff_list
);
435 list_add_tail(&ctx
->aff_list
, &neighbor
->aff_list
);
436 if (neighbor
->aff_head
) {
437 neighbor
->aff_head
= 0;
442 if (!ctx
->gang
->aff_ref_ctx
)
443 ctx
->gang
->aff_ref_ctx
= ctx
;
448 spufs_create_context(struct inode
*inode
, struct dentry
*dentry
,
449 struct vfsmount
*mnt
, int flags
, umode_t mode
,
450 struct file
*aff_filp
)
454 struct spu_gang
*gang
;
455 struct spu_context
*neighbor
;
458 if ((flags
& SPU_CREATE_NOSCHED
) &&
459 !capable(CAP_SYS_NICE
))
463 if ((flags
& (SPU_CREATE_NOSCHED
| SPU_CREATE_ISOLATE
))
464 == SPU_CREATE_ISOLATE
)
468 if ((flags
& SPU_CREATE_ISOLATE
) && !isolated_loader
)
473 affinity
= flags
& (SPU_CREATE_AFFINITY_MEM
| SPU_CREATE_AFFINITY_SPU
);
475 gang
= SPUFS_I(inode
)->i_gang
;
479 mutex_lock(&gang
->aff_mutex
);
480 neighbor
= spufs_assert_affinity(flags
, gang
, aff_filp
);
481 if (IS_ERR(neighbor
)) {
482 ret
= PTR_ERR(neighbor
);
487 ret
= spufs_mkdir(inode
, dentry
, flags
, mode
& S_IRWXUGO
);
492 spufs_set_affinity(flags
, SPUFS_I(dentry
->d_inode
)->i_ctx
,
495 put_spu_context(neighbor
);
499 * get references for dget and mntget, will be released
500 * in error path of *_open().
502 ret
= spufs_context_open(dget(dentry
), mntget(mnt
));
504 WARN_ON(spufs_rmdir(inode
, dentry
));
506 mutex_unlock(&gang
->aff_mutex
);
507 mutex_unlock(&inode
->i_mutex
);
508 spu_forget(SPUFS_I(dentry
->d_inode
)->i_ctx
);
514 mutex_unlock(&gang
->aff_mutex
);
516 mutex_unlock(&inode
->i_mutex
);
523 spufs_mkgang(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
527 struct spu_gang
*gang
;
530 inode
= spufs_new_inode(dir
->i_sb
, mode
| S_IFDIR
);
535 if (dir
->i_mode
& S_ISGID
) {
536 inode
->i_gid
= dir
->i_gid
;
537 inode
->i_mode
&= S_ISGID
;
539 gang
= alloc_spu_gang();
540 SPUFS_I(inode
)->i_ctx
= NULL
;
541 SPUFS_I(inode
)->i_gang
= gang
;
545 inode
->i_op
= &simple_dir_inode_operations
;
546 inode
->i_fop
= &simple_dir_operations
;
548 d_instantiate(dentry
, inode
);
550 inc_nlink(dentry
->d_inode
);
559 static int spufs_gang_open(struct dentry
*dentry
, struct vfsmount
*mnt
)
564 ret
= get_unused_fd();
571 filp
= dentry_open(dentry
, mnt
, O_RDONLY
, current_cred());
578 filp
->f_op
= &simple_dir_operations
;
579 fd_install(ret
, filp
);
584 static int spufs_create_gang(struct inode
*inode
,
585 struct dentry
*dentry
,
586 struct vfsmount
*mnt
, umode_t mode
)
590 ret
= spufs_mkgang(inode
, dentry
, mode
& S_IRWXUGO
);
595 * get references for dget and mntget, will be released
596 * in error path of *_open().
598 ret
= spufs_gang_open(dget(dentry
), mntget(mnt
));
600 int err
= simple_rmdir(inode
, dentry
);
605 mutex_unlock(&inode
->i_mutex
);
611 static struct file_system_type spufs_type
;
613 long spufs_create(struct path
*path
, struct dentry
*dentry
,
614 unsigned int flags
, umode_t mode
, struct file
*filp
)
619 /* check if we are on spufs */
620 if (path
->dentry
->d_sb
->s_type
!= &spufs_type
)
623 /* don't accept undefined flags */
624 if (flags
& (~SPU_CREATE_FLAG_ALL
))
627 /* only threads can be underneath a gang */
628 if (path
->dentry
!= path
->dentry
->d_sb
->s_root
) {
629 if ((flags
& SPU_CREATE_GANG
) ||
630 !SPUFS_I(path
->dentry
->d_inode
)->i_gang
)
634 mode
&= ~current_umask();
636 if (flags
& SPU_CREATE_GANG
)
637 ret
= spufs_create_gang(path
->dentry
->d_inode
,
638 dentry
, path
->mnt
, mode
);
640 ret
= spufs_create_context(path
->dentry
->d_inode
,
641 dentry
, path
->mnt
, flags
, mode
,
644 fsnotify_mkdir(path
->dentry
->d_inode
, dentry
);
648 mutex_unlock(&path
->dentry
->d_inode
->i_mutex
);
652 /* File system initialization */
654 Opt_uid
, Opt_gid
, Opt_mode
, Opt_debug
, Opt_err
,
657 static const match_table_t spufs_tokens
= {
658 { Opt_uid
, "uid=%d" },
659 { Opt_gid
, "gid=%d" },
660 { Opt_mode
, "mode=%o" },
661 { Opt_debug
, "debug" },
666 spufs_parse_options(struct super_block
*sb
, char *options
, struct inode
*root
)
669 substring_t args
[MAX_OPT_ARGS
];
671 while ((p
= strsep(&options
, ",")) != NULL
) {
677 token
= match_token(p
, spufs_tokens
, args
);
680 if (match_int(&args
[0], &option
))
682 root
->i_uid
= option
;
685 if (match_int(&args
[0], &option
))
687 root
->i_gid
= option
;
690 if (match_octal(&args
[0], &option
))
692 root
->i_mode
= option
| S_IFDIR
;
695 spufs_get_sb_info(sb
)->debug
= 1;
704 static void spufs_exit_isolated_loader(void)
706 free_pages((unsigned long) isolated_loader
,
707 get_order(isolated_loader_size
));
711 spufs_init_isolated_loader(void)
713 struct device_node
*dn
;
717 dn
= of_find_node_by_path("/spu-isolation");
721 loader
= of_get_property(dn
, "loader", &size
);
725 /* the loader must be align on a 16 byte boundary */
726 isolated_loader
= (char *)__get_free_pages(GFP_KERNEL
, get_order(size
));
727 if (!isolated_loader
)
730 isolated_loader_size
= size
;
731 memcpy(isolated_loader
, loader
, size
);
732 printk(KERN_INFO
"spufs: SPU isolation mode enabled\n");
736 spufs_create_root(struct super_block
*sb
, void *data
)
742 if (!spu_management_ops
)
746 inode
= spufs_new_inode(sb
, S_IFDIR
| 0775);
750 inode
->i_op
= &simple_dir_inode_operations
;
751 inode
->i_fop
= &simple_dir_operations
;
752 SPUFS_I(inode
)->i_ctx
= NULL
;
756 if (!spufs_parse_options(sb
, data
, inode
))
760 sb
->s_root
= d_alloc_root(inode
);
772 spufs_fill_super(struct super_block
*sb
, void *data
, int silent
)
774 struct spufs_sb_info
*info
;
775 static const struct super_operations s_ops
= {
776 .alloc_inode
= spufs_alloc_inode
,
777 .destroy_inode
= spufs_destroy_inode
,
778 .statfs
= simple_statfs
,
779 .evict_inode
= spufs_evict_inode
,
780 .show_options
= generic_show_options
,
783 save_mount_options(sb
, data
);
785 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
789 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
790 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
791 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
792 sb
->s_magic
= SPUFS_MAGIC
;
794 sb
->s_fs_info
= info
;
796 return spufs_create_root(sb
, data
);
799 static struct dentry
*
800 spufs_mount(struct file_system_type
*fstype
, int flags
,
801 const char *name
, void *data
)
803 return mount_single(fstype
, flags
, data
, spufs_fill_super
);
806 static struct file_system_type spufs_type
= {
807 .owner
= THIS_MODULE
,
809 .mount
= spufs_mount
,
810 .kill_sb
= kill_litter_super
,
813 static int __init
spufs_init(void)
818 if (!spu_management_ops
)
822 spufs_inode_cache
= kmem_cache_create("spufs_inode_cache",
823 sizeof(struct spufs_inode_info
), 0,
824 SLAB_HWCACHE_ALIGN
, spufs_init_once
);
826 if (!spufs_inode_cache
)
828 ret
= spu_sched_init();
831 ret
= register_filesystem(&spufs_type
);
834 ret
= register_spu_syscalls(&spufs_calls
);
838 spufs_init_isolated_loader();
843 unregister_filesystem(&spufs_type
);
847 kmem_cache_destroy(spufs_inode_cache
);
851 module_init(spufs_init
);
853 static void __exit
spufs_exit(void)
856 spufs_exit_isolated_loader();
857 unregister_spu_syscalls(&spufs_calls
);
858 unregister_filesystem(&spufs_type
);
859 kmem_cache_destroy(spufs_inode_cache
);
861 module_exit(spufs_exit
);
863 MODULE_LICENSE("GPL");
864 MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");