4 * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
6 * Author: Arnd Bergmann <arndb@de.ibm.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2, or (at your option)
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include <linux/file.h>
25 #include <linux/backing-dev.h>
26 #include <linux/init.h>
27 #include <linux/ioctl.h>
28 #include <linux/module.h>
29 #include <linux/mount.h>
30 #include <linux/namei.h>
31 #include <linux/pagemap.h>
32 #include <linux/poll.h>
33 #include <linux/slab.h>
34 #include <linux/parser.h>
37 #include <asm/semaphore.h>
39 #include <asm/spu_priv1.h>
40 #include <asm/uaccess.h>
44 static struct kmem_cache
*spufs_inode_cache
;
45 char *isolated_loader
;
48 spufs_alloc_inode(struct super_block
*sb
)
50 struct spufs_inode_info
*ei
;
52 ei
= kmem_cache_alloc(spufs_inode_cache
, GFP_KERNEL
);
60 return &ei
->vfs_inode
;
64 spufs_destroy_inode(struct inode
*inode
)
66 kmem_cache_free(spufs_inode_cache
, SPUFS_I(inode
));
70 spufs_init_once(void *p
, struct kmem_cache
* cachep
, unsigned long flags
)
72 struct spufs_inode_info
*ei
= p
;
74 inode_init_once(&ei
->vfs_inode
);
78 spufs_new_inode(struct super_block
*sb
, int mode
)
82 inode
= new_inode(sb
);
87 inode
->i_uid
= current
->fsuid
;
88 inode
->i_gid
= current
->fsgid
;
90 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
96 spufs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
98 struct inode
*inode
= dentry
->d_inode
;
100 if ((attr
->ia_valid
& ATTR_SIZE
) &&
101 (attr
->ia_size
!= inode
->i_size
))
103 return inode_setattr(inode
, attr
);
108 spufs_new_file(struct super_block
*sb
, struct dentry
*dentry
,
109 const struct file_operations
*fops
, int mode
,
110 struct spu_context
*ctx
)
112 static struct inode_operations spufs_file_iops
= {
113 .setattr
= spufs_setattr
,
119 inode
= spufs_new_inode(sb
, S_IFREG
| mode
);
124 inode
->i_op
= &spufs_file_iops
;
126 inode
->i_private
= SPUFS_I(inode
)->i_ctx
= get_spu_context(ctx
);
127 d_add(dentry
, inode
);
133 spufs_delete_inode(struct inode
*inode
)
135 struct spufs_inode_info
*ei
= SPUFS_I(inode
);
138 put_spu_context(ei
->i_ctx
);
140 put_spu_gang(ei
->i_gang
);
144 static void spufs_prune_dir(struct dentry
*dir
)
146 struct dentry
*dentry
, *tmp
;
148 mutex_lock(&dir
->d_inode
->i_mutex
);
149 list_for_each_entry_safe(dentry
, tmp
, &dir
->d_subdirs
, d_u
.d_child
) {
150 spin_lock(&dcache_lock
);
151 spin_lock(&dentry
->d_lock
);
152 if (!(d_unhashed(dentry
)) && dentry
->d_inode
) {
155 spin_unlock(&dentry
->d_lock
);
156 simple_unlink(dir
->d_inode
, dentry
);
157 spin_unlock(&dcache_lock
);
160 spin_unlock(&dentry
->d_lock
);
161 spin_unlock(&dcache_lock
);
164 shrink_dcache_parent(dir
);
165 mutex_unlock(&dir
->d_inode
->i_mutex
);
168 /* Caller must hold parent->i_mutex */
169 static int spufs_rmdir(struct inode
*parent
, struct dentry
*dir
)
171 /* remove all entries */
172 spufs_prune_dir(dir
);
174 return simple_rmdir(parent
, dir
);
177 static int spufs_fill_dir(struct dentry
*dir
, struct tree_descr
*files
,
178 int mode
, struct spu_context
*ctx
)
180 struct dentry
*dentry
, *tmp
;
183 while (files
->name
&& files
->name
[0]) {
185 dentry
= d_alloc_name(dir
, files
->name
);
188 ret
= spufs_new_file(dir
->d_sb
, dentry
, files
->ops
,
189 files
->mode
& mode
, ctx
);
197 * remove all children from dir. dir->inode is not set so don't
198 * just simply use spufs_prune_dir() and panic afterwards :)
199 * dput() looks like it will do the right thing:
200 * - dec parent's ref counter
201 * - remove child from parent's child list
202 * - free child's inode if possible
205 list_for_each_entry_safe(dentry
, tmp
, &dir
->d_subdirs
, d_u
.d_child
) {
209 shrink_dcache_parent(dir
);
213 static int spufs_dir_close(struct inode
*inode
, struct file
*file
)
215 struct spu_context
*ctx
;
216 struct inode
*parent
;
220 dir
= file
->f_path
.dentry
;
221 parent
= dir
->d_parent
->d_inode
;
222 ctx
= SPUFS_I(dir
->d_inode
)->i_ctx
;
224 mutex_lock(&parent
->i_mutex
);
225 ret
= spufs_rmdir(parent
, dir
);
226 mutex_unlock(&parent
->i_mutex
);
229 /* We have to give up the mm_struct */
232 return dcache_dir_close(inode
, file
);
235 const struct file_operations spufs_context_fops
= {
236 .open
= dcache_dir_open
,
237 .release
= spufs_dir_close
,
238 .llseek
= dcache_dir_lseek
,
239 .read
= generic_read_dir
,
240 .readdir
= dcache_readdir
,
241 .fsync
= simple_sync_file
,
243 EXPORT_SYMBOL_GPL(spufs_context_fops
);
246 spufs_mkdir(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
,
251 struct spu_context
*ctx
;
254 inode
= spufs_new_inode(dir
->i_sb
, mode
| S_IFDIR
);
258 if (dir
->i_mode
& S_ISGID
) {
259 inode
->i_gid
= dir
->i_gid
;
260 inode
->i_mode
&= S_ISGID
;
262 ctx
= alloc_spu_context(SPUFS_I(dir
)->i_gang
); /* XXX gang */
263 SPUFS_I(inode
)->i_ctx
= ctx
;
268 inode
->i_op
= &simple_dir_inode_operations
;
269 inode
->i_fop
= &simple_dir_operations
;
270 if (flags
& SPU_CREATE_NOSCHED
)
271 ret
= spufs_fill_dir(dentry
, spufs_dir_nosched_contents
,
274 ret
= spufs_fill_dir(dentry
, spufs_dir_contents
, mode
, ctx
);
279 d_instantiate(dentry
, inode
);
282 dentry
->d_inode
->i_nlink
++;
287 put_spu_context(ctx
);
294 static int spufs_context_open(struct dentry
*dentry
, struct vfsmount
*mnt
)
299 ret
= get_unused_fd();
306 filp
= dentry_open(dentry
, mnt
, O_RDONLY
);
313 filp
->f_op
= &spufs_context_fops
;
314 fd_install(ret
, filp
);
319 static struct spu_context
*
320 spufs_assert_affinity(unsigned int flags
, struct spu_gang
*gang
,
323 struct spu_context
*tmp
, *neighbor
;
327 aff_supp
= !list_empty(&(list_entry(cbe_spu_info
[0].spus
.next
,
328 struct spu
, cbe_list
))->aff_list
);
331 return ERR_PTR(-EINVAL
);
333 if (flags
& SPU_CREATE_GANG
)
334 return ERR_PTR(-EINVAL
);
336 if (flags
& SPU_CREATE_AFFINITY_MEM
&&
338 gang
->aff_ref_ctx
->flags
& SPU_CREATE_AFFINITY_MEM
)
339 return ERR_PTR(-EEXIST
);
341 if (gang
->aff_flags
& AFF_MERGED
)
342 return ERR_PTR(-EBUSY
);
345 if (flags
& SPU_CREATE_AFFINITY_SPU
) {
346 if (!filp
|| filp
->f_op
!= &spufs_context_fops
)
347 return ERR_PTR(-EINVAL
);
349 neighbor
= get_spu_context(
350 SPUFS_I(filp
->f_dentry
->d_inode
)->i_ctx
);
352 if (!list_empty(&neighbor
->aff_list
) && !(neighbor
->aff_head
) &&
353 !list_is_last(&neighbor
->aff_list
, &gang
->aff_list_head
) &&
354 !list_entry(neighbor
->aff_list
.next
, struct spu_context
,
356 return ERR_PTR(-EEXIST
);
358 if (gang
!= neighbor
->gang
)
359 return ERR_PTR(-EINVAL
);
362 list_for_each_entry(tmp
, &gang
->aff_list_head
, aff_list
)
364 if (list_empty(&neighbor
->aff_list
))
367 for (node
= 0; node
< MAX_NUMNODES
; node
++) {
368 if ((cbe_spu_info
[node
].n_spus
- atomic_read(
369 &cbe_spu_info
[node
].reserved_spus
)) >= count
)
373 if (node
== MAX_NUMNODES
)
374 return ERR_PTR(-EEXIST
);
381 spufs_set_affinity(unsigned int flags
, struct spu_context
*ctx
,
382 struct spu_context
*neighbor
)
384 if (flags
& SPU_CREATE_AFFINITY_MEM
)
385 ctx
->gang
->aff_ref_ctx
= ctx
;
387 if (flags
& SPU_CREATE_AFFINITY_SPU
) {
388 if (list_empty(&neighbor
->aff_list
)) {
389 list_add_tail(&neighbor
->aff_list
,
390 &ctx
->gang
->aff_list_head
);
391 neighbor
->aff_head
= 1;
394 if (list_is_last(&neighbor
->aff_list
, &ctx
->gang
->aff_list_head
)
395 || list_entry(neighbor
->aff_list
.next
, struct spu_context
,
396 aff_list
)->aff_head
) {
397 list_add(&ctx
->aff_list
, &neighbor
->aff_list
);
399 list_add_tail(&ctx
->aff_list
, &neighbor
->aff_list
);
400 if (neighbor
->aff_head
) {
401 neighbor
->aff_head
= 0;
406 if (!ctx
->gang
->aff_ref_ctx
)
407 ctx
->gang
->aff_ref_ctx
= ctx
;
412 spufs_create_context(struct inode
*inode
, struct dentry
*dentry
,
413 struct vfsmount
*mnt
, int flags
, int mode
,
414 struct file
*aff_filp
)
418 struct spu_gang
*gang
;
419 struct spu_context
*neighbor
;
422 if ((flags
& SPU_CREATE_NOSCHED
) &&
423 !capable(CAP_SYS_NICE
))
427 if ((flags
& (SPU_CREATE_NOSCHED
| SPU_CREATE_ISOLATE
))
428 == SPU_CREATE_ISOLATE
)
432 if ((flags
& SPU_CREATE_ISOLATE
) && !isolated_loader
)
437 affinity
= flags
& (SPU_CREATE_AFFINITY_MEM
| SPU_CREATE_AFFINITY_SPU
);
439 gang
= SPUFS_I(inode
)->i_gang
;
443 mutex_lock(&gang
->aff_mutex
);
444 neighbor
= spufs_assert_affinity(flags
, gang
, aff_filp
);
445 if (IS_ERR(neighbor
)) {
446 ret
= PTR_ERR(neighbor
);
451 ret
= spufs_mkdir(inode
, dentry
, flags
, mode
& S_IRWXUGO
);
456 spufs_set_affinity(flags
, SPUFS_I(dentry
->d_inode
)->i_ctx
,
460 * get references for dget and mntget, will be released
461 * in error path of *_open().
463 ret
= spufs_context_open(dget(dentry
), mntget(mnt
));
465 WARN_ON(spufs_rmdir(inode
, dentry
));
466 mutex_unlock(&inode
->i_mutex
);
467 spu_forget(SPUFS_I(dentry
->d_inode
)->i_ctx
);
473 mutex_unlock(&gang
->aff_mutex
);
475 mutex_unlock(&inode
->i_mutex
);
482 spufs_mkgang(struct inode
*dir
, struct dentry
*dentry
, int mode
)
486 struct spu_gang
*gang
;
489 inode
= spufs_new_inode(dir
->i_sb
, mode
| S_IFDIR
);
494 if (dir
->i_mode
& S_ISGID
) {
495 inode
->i_gid
= dir
->i_gid
;
496 inode
->i_mode
&= S_ISGID
;
498 gang
= alloc_spu_gang();
499 SPUFS_I(inode
)->i_ctx
= NULL
;
500 SPUFS_I(inode
)->i_gang
= gang
;
504 inode
->i_op
= &simple_dir_inode_operations
;
505 inode
->i_fop
= &simple_dir_operations
;
507 d_instantiate(dentry
, inode
);
509 dentry
->d_inode
->i_nlink
++;
518 static int spufs_gang_open(struct dentry
*dentry
, struct vfsmount
*mnt
)
523 ret
= get_unused_fd();
530 filp
= dentry_open(dentry
, mnt
, O_RDONLY
);
537 filp
->f_op
= &simple_dir_operations
;
538 fd_install(ret
, filp
);
543 static int spufs_create_gang(struct inode
*inode
,
544 struct dentry
*dentry
,
545 struct vfsmount
*mnt
, int mode
)
549 ret
= spufs_mkgang(inode
, dentry
, mode
& S_IRWXUGO
);
554 * get references for dget and mntget, will be released
555 * in error path of *_open().
557 ret
= spufs_gang_open(dget(dentry
), mntget(mnt
));
559 int err
= simple_rmdir(inode
, dentry
);
564 mutex_unlock(&inode
->i_mutex
);
570 static struct file_system_type spufs_type
;
572 long spufs_create(struct nameidata
*nd
, unsigned int flags
, mode_t mode
,
575 struct dentry
*dentry
;
579 /* check if we are on spufs */
580 if (nd
->dentry
->d_sb
->s_type
!= &spufs_type
)
583 /* don't accept undefined flags */
584 if (flags
& (~SPU_CREATE_FLAG_ALL
))
587 /* only threads can be underneath a gang */
588 if (nd
->dentry
!= nd
->dentry
->d_sb
->s_root
) {
589 if ((flags
& SPU_CREATE_GANG
) ||
590 !SPUFS_I(nd
->dentry
->d_inode
)->i_gang
)
594 dentry
= lookup_create(nd
, 1);
595 ret
= PTR_ERR(dentry
);
603 mode
&= ~current
->fs
->umask
;
605 if (flags
& SPU_CREATE_GANG
)
606 return spufs_create_gang(nd
->dentry
->d_inode
,
607 dentry
, nd
->mnt
, mode
);
609 return spufs_create_context(nd
->dentry
->d_inode
,
610 dentry
, nd
->mnt
, flags
, mode
, filp
);
615 mutex_unlock(&nd
->dentry
->d_inode
->i_mutex
);
620 /* File system initialization */
622 Opt_uid
, Opt_gid
, Opt_mode
, Opt_err
,
625 static match_table_t spufs_tokens
= {
626 { Opt_uid
, "uid=%d" },
627 { Opt_gid
, "gid=%d" },
628 { Opt_mode
, "mode=%o" },
633 spufs_parse_options(char *options
, struct inode
*root
)
636 substring_t args
[MAX_OPT_ARGS
];
638 while ((p
= strsep(&options
, ",")) != NULL
) {
644 token
= match_token(p
, spufs_tokens
, args
);
647 if (match_int(&args
[0], &option
))
649 root
->i_uid
= option
;
652 if (match_int(&args
[0], &option
))
654 root
->i_gid
= option
;
657 if (match_octal(&args
[0], &option
))
659 root
->i_mode
= option
| S_IFDIR
;
668 static void spufs_exit_isolated_loader(void)
670 kfree(isolated_loader
);
674 spufs_init_isolated_loader(void)
676 struct device_node
*dn
;
680 dn
= of_find_node_by_path("/spu-isolation");
684 loader
= of_get_property(dn
, "loader", &size
);
688 /* kmalloc should align on a 16 byte boundary..* */
689 isolated_loader
= kmalloc(size
, GFP_KERNEL
);
690 if (!isolated_loader
)
693 memcpy(isolated_loader
, loader
, size
);
694 printk(KERN_INFO
"spufs: SPU isolation mode enabled\n");
698 spufs_create_root(struct super_block
*sb
, void *data
)
704 if (!spu_management_ops
)
708 inode
= spufs_new_inode(sb
, S_IFDIR
| 0775);
712 inode
->i_op
= &simple_dir_inode_operations
;
713 inode
->i_fop
= &simple_dir_operations
;
714 SPUFS_I(inode
)->i_ctx
= NULL
;
717 if (!spufs_parse_options(data
, inode
))
721 sb
->s_root
= d_alloc_root(inode
);
733 spufs_fill_super(struct super_block
*sb
, void *data
, int silent
)
735 static struct super_operations s_ops
= {
736 .alloc_inode
= spufs_alloc_inode
,
737 .destroy_inode
= spufs_destroy_inode
,
738 .statfs
= simple_statfs
,
739 .delete_inode
= spufs_delete_inode
,
740 .drop_inode
= generic_delete_inode
,
743 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
744 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
745 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
746 sb
->s_magic
= SPUFS_MAGIC
;
749 return spufs_create_root(sb
, data
);
753 spufs_get_sb(struct file_system_type
*fstype
, int flags
,
754 const char *name
, void *data
, struct vfsmount
*mnt
)
756 return get_sb_single(fstype
, flags
, data
, spufs_fill_super
, mnt
);
759 static struct file_system_type spufs_type
= {
760 .owner
= THIS_MODULE
,
762 .get_sb
= spufs_get_sb
,
763 .kill_sb
= kill_litter_super
,
766 static int __init
spufs_init(void)
771 if (!spu_management_ops
)
775 spufs_inode_cache
= kmem_cache_create("spufs_inode_cache",
776 sizeof(struct spufs_inode_info
), 0,
777 SLAB_HWCACHE_ALIGN
, spufs_init_once
);
779 if (!spufs_inode_cache
)
781 ret
= spu_sched_init();
784 ret
= register_filesystem(&spufs_type
);
787 ret
= register_spu_syscalls(&spufs_calls
);
790 ret
= register_arch_coredump_calls(&spufs_coredump_calls
);
794 spufs_init_isolated_loader();
799 unregister_spu_syscalls(&spufs_calls
);
801 unregister_filesystem(&spufs_type
);
805 kmem_cache_destroy(spufs_inode_cache
);
809 module_init(spufs_init
);
811 static void __exit
spufs_exit(void)
814 spufs_exit_isolated_loader();
815 unregister_arch_coredump_calls(&spufs_coredump_calls
);
816 unregister_spu_syscalls(&spufs_calls
);
817 unregister_filesystem(&spufs_type
);
818 kmem_cache_destroy(spufs_inode_cache
);
820 module_exit(spufs_exit
);
822 MODULE_LICENSE("GPL");
823 MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");