2 * VFS-related code for RelayFS, a high-speed data relay filesystem.
4 * Copyright (C) 2003-2005 - Tom Zanussi <zanussi@us.ibm.com>, IBM Corp
5 * Copyright (C) 2003-2005 - Karim Yaghmour <karim@opersys.com>
7 * Based on ramfs, Copyright (C) 2002 - Linus Torvalds
9 * This file is released under the GPL.
12 #include <linux/module.h>
14 #include <linux/mount.h>
15 #include <linux/pagemap.h>
16 #include <linux/init.h>
17 #include <linux/string.h>
18 #include <linux/backing-dev.h>
19 #include <linux/namei.h>
20 #include <linux/poll.h>
21 #include <linux/relayfs_fs.h>
25 #define RELAYFS_MAGIC 0xF0B4A981
27 static struct vfsmount
* relayfs_mount
;
28 static int relayfs_mount_count
;
30 static struct backing_dev_info relayfs_backing_dev_info
= {
31 .ra_pages
= 0, /* No readahead */
32 .capabilities
= BDI_CAP_NO_ACCT_DIRTY
| BDI_CAP_NO_WRITEBACK
,
35 static struct inode
*relayfs_get_inode(struct super_block
*sb
,
37 struct file_operations
*fops
,
42 inode
= new_inode(sb
);
49 inode
->i_blksize
= PAGE_CACHE_SIZE
;
51 inode
->i_mapping
->backing_dev_info
= &relayfs_backing_dev_info
;
52 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
53 switch (mode
& S_IFMT
) {
57 inode
->u
.generic_ip
= data
;
60 inode
->i_op
= &simple_dir_inode_operations
;
61 inode
->i_fop
= &simple_dir_operations
;
63 /* directory inodes start off with i_nlink == 2 (for "." entry) */
74 * relayfs_create_entry - create a relayfs directory or file
75 * @name: the name of the file to create
76 * @parent: parent directory
78 * @fops: file operations to use for the file
79 * @data: user-associated data for this file
81 * Returns the new dentry, NULL on failure
83 * Creates a file or directory with the specifed permissions.
85 static struct dentry
*relayfs_create_entry(const char *name
,
86 struct dentry
*parent
,
88 struct file_operations
*fops
,
95 BUG_ON(!name
|| !(S_ISREG(mode
) || S_ISDIR(mode
)));
97 error
= simple_pin_fs("relayfs", &relayfs_mount
, &relayfs_mount_count
);
99 printk(KERN_ERR
"Couldn't mount relayfs: errcode %d\n", error
);
103 if (!parent
&& relayfs_mount
&& relayfs_mount
->mnt_sb
)
104 parent
= relayfs_mount
->mnt_sb
->s_root
;
107 simple_release_fs(&relayfs_mount
, &relayfs_mount_count
);
111 parent
= dget(parent
);
112 mutex_lock(&parent
->d_inode
->i_mutex
);
113 d
= lookup_one_len(name
, parent
, strlen(name
));
124 inode
= relayfs_get_inode(parent
->d_inode
->i_sb
, mode
, fops
, data
);
130 d_instantiate(d
, inode
);
131 dget(d
); /* Extra count - pin the dentry in core */
134 parent
->d_inode
->i_nlink
++;
139 simple_release_fs(&relayfs_mount
, &relayfs_mount_count
);
142 mutex_unlock(&parent
->d_inode
->i_mutex
);
148 * relayfs_create_file - create a file in the relay filesystem
149 * @name: the name of the file to create
150 * @parent: parent directory
151 * @mode: mode, if not specied the default perms are used
152 * @fops: file operations to use for the file
153 * @data: user-associated data for this file
155 * Returns file dentry if successful, NULL otherwise.
157 * The file will be created user r on behalf of current user.
159 struct dentry
*relayfs_create_file(const char *name
,
160 struct dentry
*parent
,
162 struct file_operations
*fops
,
169 mode
= (mode
& S_IALLUGO
) | S_IFREG
;
171 return relayfs_create_entry(name
, parent
, mode
, fops
, data
);
175 * relayfs_create_dir - create a directory in the relay filesystem
176 * @name: the name of the directory to create
177 * @parent: parent directory, NULL if parent should be fs root
179 * Returns directory dentry if successful, NULL otherwise.
181 * The directory will be created world rwx on behalf of current user.
183 struct dentry
*relayfs_create_dir(const char *name
, struct dentry
*parent
)
185 int mode
= S_IFDIR
| S_IRWXU
| S_IRUGO
| S_IXUGO
;
186 return relayfs_create_entry(name
, parent
, mode
, NULL
, NULL
);
190 * relayfs_remove - remove a file or directory in the relay filesystem
191 * @dentry: file or directory dentry
193 * Returns 0 if successful, negative otherwise.
195 int relayfs_remove(struct dentry
*dentry
)
197 struct dentry
*parent
;
202 parent
= dentry
->d_parent
;
206 parent
= dget(parent
);
207 mutex_lock(&parent
->d_inode
->i_mutex
);
208 if (dentry
->d_inode
) {
209 if (S_ISDIR(dentry
->d_inode
->i_mode
))
210 error
= simple_rmdir(parent
->d_inode
, dentry
);
212 error
= simple_unlink(parent
->d_inode
, dentry
);
218 mutex_unlock(&parent
->d_inode
->i_mutex
);
222 simple_release_fs(&relayfs_mount
, &relayfs_mount_count
);
228 * relayfs_remove_file - remove a file from relay filesystem
229 * @dentry: directory dentry
231 * Returns 0 if successful, negative otherwise.
233 int relayfs_remove_file(struct dentry
*dentry
)
235 return relayfs_remove(dentry
);
239 * relayfs_remove_dir - remove a directory in the relay filesystem
240 * @dentry: directory dentry
242 * Returns 0 if successful, negative otherwise.
244 int relayfs_remove_dir(struct dentry
*dentry
)
246 return relayfs_remove(dentry
);
250 * relay_file_open - open file op for relay files
254 * Increments the channel buffer refcount.
256 static int relay_file_open(struct inode
*inode
, struct file
*filp
)
258 struct rchan_buf
*buf
= inode
->u
.generic_ip
;
259 kref_get(&buf
->kref
);
260 filp
->private_data
= buf
;
266 * relay_file_mmap - mmap file op for relay files
268 * @vma: the vma describing what to map
270 * Calls upon relay_mmap_buf to map the file into user space.
272 static int relay_file_mmap(struct file
*filp
, struct vm_area_struct
*vma
)
274 struct rchan_buf
*buf
= filp
->private_data
;
275 return relay_mmap_buf(buf
, vma
);
279 * relay_file_poll - poll file op for relay files
285 static unsigned int relay_file_poll(struct file
*filp
, poll_table
*wait
)
287 unsigned int mask
= 0;
288 struct rchan_buf
*buf
= filp
->private_data
;
293 if (filp
->f_mode
& FMODE_READ
) {
294 poll_wait(filp
, &buf
->read_wait
, wait
);
295 if (!relay_buf_empty(buf
))
296 mask
|= POLLIN
| POLLRDNORM
;
303 * relay_file_release - release file op for relay files
307 * Decrements the channel refcount, as the filesystem is
308 * no longer using it.
310 static int relay_file_release(struct inode
*inode
, struct file
*filp
)
312 struct rchan_buf
*buf
= filp
->private_data
;
313 kref_put(&buf
->kref
, relay_remove_buf
);
319 * relay_file_read_consume - update the consumed count for the buffer
321 static void relay_file_read_consume(struct rchan_buf
*buf
,
323 size_t bytes_consumed
)
325 size_t subbuf_size
= buf
->chan
->subbuf_size
;
326 size_t n_subbufs
= buf
->chan
->n_subbufs
;
329 if (buf
->bytes_consumed
+ bytes_consumed
> subbuf_size
) {
330 relay_subbufs_consumed(buf
->chan
, buf
->cpu
, 1);
331 buf
->bytes_consumed
= 0;
334 buf
->bytes_consumed
+= bytes_consumed
;
335 read_subbuf
= read_pos
/ buf
->chan
->subbuf_size
;
336 if (buf
->bytes_consumed
+ buf
->padding
[read_subbuf
] == subbuf_size
) {
337 if ((read_subbuf
== buf
->subbufs_produced
% n_subbufs
) &&
338 (buf
->offset
== subbuf_size
))
340 relay_subbufs_consumed(buf
->chan
, buf
->cpu
, 1);
341 buf
->bytes_consumed
= 0;
346 * relay_file_read_avail - boolean, are there unconsumed bytes available?
348 static int relay_file_read_avail(struct rchan_buf
*buf
, size_t read_pos
)
350 size_t bytes_produced
, bytes_consumed
, write_offset
;
351 size_t subbuf_size
= buf
->chan
->subbuf_size
;
352 size_t n_subbufs
= buf
->chan
->n_subbufs
;
353 size_t produced
= buf
->subbufs_produced
% n_subbufs
;
354 size_t consumed
= buf
->subbufs_consumed
% n_subbufs
;
356 write_offset
= buf
->offset
> subbuf_size
? subbuf_size
: buf
->offset
;
358 if (consumed
> produced
) {
359 if ((produced
> n_subbufs
) &&
360 (produced
+ n_subbufs
- consumed
<= n_subbufs
))
361 produced
+= n_subbufs
;
362 } else if (consumed
== produced
) {
363 if (buf
->offset
> subbuf_size
) {
364 produced
+= n_subbufs
;
365 if (buf
->subbufs_produced
== buf
->subbufs_consumed
)
366 consumed
+= n_subbufs
;
370 if (buf
->offset
> subbuf_size
)
371 bytes_produced
= (produced
- 1) * subbuf_size
+ write_offset
;
373 bytes_produced
= produced
* subbuf_size
+ write_offset
;
374 bytes_consumed
= consumed
* subbuf_size
+ buf
->bytes_consumed
;
376 if (bytes_produced
== bytes_consumed
)
379 relay_file_read_consume(buf
, read_pos
, 0);
385 * relay_file_read_subbuf_avail - return bytes available in sub-buffer
387 static size_t relay_file_read_subbuf_avail(size_t read_pos
,
388 struct rchan_buf
*buf
)
390 size_t padding
, avail
= 0;
391 size_t read_subbuf
, read_offset
, write_subbuf
, write_offset
;
392 size_t subbuf_size
= buf
->chan
->subbuf_size
;
394 write_subbuf
= (buf
->data
- buf
->start
) / subbuf_size
;
395 write_offset
= buf
->offset
> subbuf_size
? subbuf_size
: buf
->offset
;
396 read_subbuf
= read_pos
/ subbuf_size
;
397 read_offset
= read_pos
% subbuf_size
;
398 padding
= buf
->padding
[read_subbuf
];
400 if (read_subbuf
== write_subbuf
) {
401 if (read_offset
+ padding
< write_offset
)
402 avail
= write_offset
- (read_offset
+ padding
);
404 avail
= (subbuf_size
- padding
) - read_offset
;
410 * relay_file_read_start_pos - find the first available byte to read
412 * If the read_pos is in the middle of padding, return the
413 * position of the first actually available byte, otherwise
414 * return the original value.
416 static size_t relay_file_read_start_pos(size_t read_pos
,
417 struct rchan_buf
*buf
)
419 size_t read_subbuf
, padding
, padding_start
, padding_end
;
420 size_t subbuf_size
= buf
->chan
->subbuf_size
;
421 size_t n_subbufs
= buf
->chan
->n_subbufs
;
423 read_subbuf
= read_pos
/ subbuf_size
;
424 padding
= buf
->padding
[read_subbuf
];
425 padding_start
= (read_subbuf
+ 1) * subbuf_size
- padding
;
426 padding_end
= (read_subbuf
+ 1) * subbuf_size
;
427 if (read_pos
>= padding_start
&& read_pos
< padding_end
) {
428 read_subbuf
= (read_subbuf
+ 1) % n_subbufs
;
429 read_pos
= read_subbuf
* subbuf_size
;
436 * relay_file_read_end_pos - return the new read position
438 static size_t relay_file_read_end_pos(struct rchan_buf
*buf
,
442 size_t read_subbuf
, padding
, end_pos
;
443 size_t subbuf_size
= buf
->chan
->subbuf_size
;
444 size_t n_subbufs
= buf
->chan
->n_subbufs
;
446 read_subbuf
= read_pos
/ subbuf_size
;
447 padding
= buf
->padding
[read_subbuf
];
448 if (read_pos
% subbuf_size
+ count
+ padding
== subbuf_size
)
449 end_pos
= (read_subbuf
+ 1) * subbuf_size
;
451 end_pos
= read_pos
+ count
;
452 if (end_pos
>= subbuf_size
* n_subbufs
)
459 * relay_file_read - read file op for relay files
461 * @buffer: the userspace buffer
462 * @count: number of bytes to read
463 * @ppos: position to read from
465 * Reads count bytes or the number of bytes available in the
466 * current sub-buffer being read, whichever is smaller.
468 static ssize_t
relay_file_read(struct file
*filp
,
473 struct rchan_buf
*buf
= filp
->private_data
;
474 struct inode
*inode
= filp
->f_dentry
->d_inode
;
475 size_t read_start
, avail
;
479 mutex_lock(&inode
->i_mutex
);
480 if(!relay_file_read_avail(buf
, *ppos
))
483 read_start
= relay_file_read_start_pos(*ppos
, buf
);
484 avail
= relay_file_read_subbuf_avail(read_start
, buf
);
488 from
= buf
->start
+ read_start
;
489 ret
= count
= min(count
, avail
);
490 if (copy_to_user(buffer
, from
, count
)) {
494 relay_file_read_consume(buf
, read_start
, count
);
495 *ppos
= relay_file_read_end_pos(buf
, read_start
, count
);
497 mutex_unlock(&inode
->i_mutex
);
501 struct file_operations relay_file_operations
= {
502 .open
= relay_file_open
,
503 .poll
= relay_file_poll
,
504 .mmap
= relay_file_mmap
,
505 .read
= relay_file_read
,
507 .release
= relay_file_release
,
510 static struct super_operations relayfs_ops
= {
511 .statfs
= simple_statfs
,
512 .drop_inode
= generic_delete_inode
,
515 static int relayfs_fill_super(struct super_block
* sb
, void * data
, int silent
)
519 int mode
= S_IFDIR
| S_IRWXU
| S_IRUGO
| S_IXUGO
;
521 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
522 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
523 sb
->s_magic
= RELAYFS_MAGIC
;
524 sb
->s_op
= &relayfs_ops
;
525 inode
= relayfs_get_inode(sb
, mode
, NULL
, NULL
);
530 root
= d_alloc_root(inode
);
540 static struct super_block
* relayfs_get_sb(struct file_system_type
*fs_type
,
541 int flags
, const char *dev_name
,
544 return get_sb_single(fs_type
, flags
, data
, relayfs_fill_super
);
547 static struct file_system_type relayfs_fs_type
= {
548 .owner
= THIS_MODULE
,
550 .get_sb
= relayfs_get_sb
,
551 .kill_sb
= kill_litter_super
,
554 static int __init
init_relayfs_fs(void)
556 return register_filesystem(&relayfs_fs_type
);
559 static void __exit
exit_relayfs_fs(void)
566 unregister_filesystem(&relayfs_fs_type
);
569 module_init(init_relayfs_fs
)
570 module_exit(exit_relayfs_fs
)
572 EXPORT_SYMBOL_GPL(relay_file_operations
);
573 EXPORT_SYMBOL_GPL(relayfs_create_dir
);
574 EXPORT_SYMBOL_GPL(relayfs_remove_dir
);
575 EXPORT_SYMBOL_GPL(relayfs_create_file
);
576 EXPORT_SYMBOL_GPL(relayfs_remove_file
);
578 MODULE_AUTHOR("Tom Zanussi <zanussi@us.ibm.com> and Karim Yaghmour <karim@opersys.com>");
579 MODULE_DESCRIPTION("Relay Filesystem");
580 MODULE_LICENSE("GPL");