1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
6 * Code which implements the kernel side of a minimal userspace
7 * interface to our DLM. This file handles the virtual file system
8 * used for communication with userspace. Credit should go to ramfs,
9 * which was a template for the fs side of this module.
11 * Copyright (C) 2003, 2004 Oracle. All rights reserved.
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public
15 * License as published by the Free Software Foundation; either
16 * version 2 of the License, or (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
23 * You should have received a copy of the GNU General Public
24 * License along with this program; if not, write to the
25 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
26 * Boston, MA 021110-1307, USA.
29 /* Simple VFS hooks based on: */
31 * Resizable simple ram filesystem for Linux.
33 * Copyright (C) 2000 Linus Torvalds.
34 * 2000 Transmeta Corp.
37 #include <linux/module.h>
39 #include <linux/pagemap.h>
40 #include <linux/types.h>
41 #include <linux/slab.h>
42 #include <linux/highmem.h>
43 #include <linux/init.h>
44 #include <linux/string.h>
45 #include <linux/backing-dev.h>
47 #include <asm/uaccess.h>
50 #include "cluster/nodemanager.h"
51 #include "cluster/heartbeat.h"
52 #include "cluster/tcp.h"
60 #define MLOG_MASK_PREFIX ML_DLMFS
61 #include "cluster/masklog.h"
63 static const struct super_operations dlmfs_ops
;
64 static const struct file_operations dlmfs_file_operations
;
65 static const struct inode_operations dlmfs_dir_inode_operations
;
66 static const struct inode_operations dlmfs_root_inode_operations
;
67 static const struct inode_operations dlmfs_file_inode_operations
;
68 static struct kmem_cache
*dlmfs_inode_cache
;
70 struct workqueue_struct
*user_dlm_worker
;
73 * decodes a set of open flags into a valid lock level and a set of flags.
74 * returns < 0 if we have invalid flags
75 * flags which mean something to us:
76 * O_RDONLY -> PRMODE level
77 * O_WRONLY -> EXMODE level
79 * O_NONBLOCK -> LKM_NOQUEUE
81 static int dlmfs_decode_open_flags(int open_flags
,
85 if (open_flags
& (O_WRONLY
|O_RDWR
))
91 if (open_flags
& O_NONBLOCK
)
92 *flags
|= LKM_NOQUEUE
;
97 static int dlmfs_file_open(struct inode
*inode
,
100 int status
, level
, flags
;
101 struct dlmfs_filp_private
*fp
= NULL
;
102 struct dlmfs_inode_private
*ip
;
104 if (S_ISDIR(inode
->i_mode
))
107 mlog(0, "open called on inode %lu, flags 0x%x\n", inode
->i_ino
,
110 status
= dlmfs_decode_open_flags(file
->f_flags
, &level
, &flags
);
114 /* We don't want to honor O_APPEND at read/write time as it
115 * doesn't make sense for LVB writes. */
116 file
->f_flags
&= ~O_APPEND
;
118 fp
= kmalloc(sizeof(*fp
), GFP_NOFS
);
123 fp
->fp_lock_level
= level
;
127 status
= user_dlm_cluster_lock(&ip
->ip_lockres
, level
, flags
);
129 /* this is a strange error to return here but I want
130 * to be able userspace to be able to distinguish a
131 * valid lock request from one that simply couldn't be
133 if (flags
& LKM_NOQUEUE
&& status
== -EAGAIN
)
139 file
->private_data
= fp
;
144 static int dlmfs_file_release(struct inode
*inode
,
148 struct dlmfs_inode_private
*ip
= DLMFS_I(inode
);
149 struct dlmfs_filp_private
*fp
=
150 (struct dlmfs_filp_private
*) file
->private_data
;
152 if (S_ISDIR(inode
->i_mode
))
155 mlog(0, "close called on inode %lu\n", inode
->i_ino
);
159 level
= fp
->fp_lock_level
;
160 if (level
!= LKM_IVMODE
)
161 user_dlm_cluster_unlock(&ip
->ip_lockres
, level
);
164 file
->private_data
= NULL
;
170 static ssize_t
dlmfs_file_read(struct file
*filp
,
178 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
180 mlog(0, "inode %lu, count = %zu, *ppos = %llu\n",
181 inode
->i_ino
, count
, *ppos
);
183 if (*ppos
>= i_size_read(inode
))
189 if (!access_ok(VERIFY_WRITE
, buf
, count
))
192 /* don't read past the lvb */
193 if ((count
+ *ppos
) > i_size_read(inode
))
194 readlen
= i_size_read(inode
) - *ppos
;
196 readlen
= count
- *ppos
;
198 lvb_buf
= kmalloc(readlen
, GFP_NOFS
);
202 user_dlm_read_lvb(inode
, lvb_buf
, readlen
);
203 bytes_left
= __copy_to_user(buf
, lvb_buf
, readlen
);
204 readlen
-= bytes_left
;
208 *ppos
= *ppos
+ readlen
;
210 mlog(0, "read %zd bytes\n", readlen
);
214 static ssize_t
dlmfs_file_write(struct file
*filp
,
215 const char __user
*buf
,
222 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
224 mlog(0, "inode %lu, count = %zu, *ppos = %llu\n",
225 inode
->i_ino
, count
, *ppos
);
227 if (*ppos
>= i_size_read(inode
))
233 if (!access_ok(VERIFY_READ
, buf
, count
))
236 /* don't write past the lvb */
237 if ((count
+ *ppos
) > i_size_read(inode
))
238 writelen
= i_size_read(inode
) - *ppos
;
240 writelen
= count
- *ppos
;
242 lvb_buf
= kmalloc(writelen
, GFP_NOFS
);
246 bytes_left
= copy_from_user(lvb_buf
, buf
, writelen
);
247 writelen
-= bytes_left
;
249 user_dlm_write_lvb(inode
, lvb_buf
, writelen
);
253 *ppos
= *ppos
+ writelen
;
254 mlog(0, "wrote %zd bytes\n", writelen
);
258 static void dlmfs_init_once(void *foo
,
259 struct kmem_cache
*cachep
,
262 struct dlmfs_inode_private
*ip
=
263 (struct dlmfs_inode_private
*) foo
;
265 if (flags
& SLAB_CTOR_CONSTRUCTOR
) {
267 ip
->ip_parent
= NULL
;
269 inode_init_once(&ip
->ip_vfs_inode
);
273 static struct inode
*dlmfs_alloc_inode(struct super_block
*sb
)
275 struct dlmfs_inode_private
*ip
;
277 ip
= kmem_cache_alloc(dlmfs_inode_cache
, GFP_NOFS
);
281 return &ip
->ip_vfs_inode
;
284 static void dlmfs_destroy_inode(struct inode
*inode
)
286 kmem_cache_free(dlmfs_inode_cache
, DLMFS_I(inode
));
289 static void dlmfs_clear_inode(struct inode
*inode
)
292 struct dlmfs_inode_private
*ip
;
297 mlog(0, "inode %lu\n", inode
->i_ino
);
301 if (S_ISREG(inode
->i_mode
)) {
302 status
= user_dlm_destroy_lock(&ip
->ip_lockres
);
309 mlog(0, "we're a directory, ip->ip_dlm = 0x%p\n", ip
->ip_dlm
);
310 /* we must be a directory. If required, lets unregister the
311 * dlm context now. */
313 user_dlm_unregister_context(ip
->ip_dlm
);
315 ip
->ip_parent
= NULL
;
319 static struct backing_dev_info dlmfs_backing_dev_info
= {
320 .ra_pages
= 0, /* No readahead */
321 .capabilities
= BDI_CAP_NO_ACCT_DIRTY
| BDI_CAP_NO_WRITEBACK
,
324 static struct inode
*dlmfs_get_root_inode(struct super_block
*sb
)
326 struct inode
*inode
= new_inode(sb
);
327 int mode
= S_IFDIR
| 0755;
328 struct dlmfs_inode_private
*ip
;
333 inode
->i_mode
= mode
;
334 inode
->i_uid
= current
->fsuid
;
335 inode
->i_gid
= current
->fsgid
;
337 inode
->i_mapping
->backing_dev_info
= &dlmfs_backing_dev_info
;
338 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
341 inode
->i_fop
= &simple_dir_operations
;
342 inode
->i_op
= &dlmfs_root_inode_operations
;
348 static struct inode
*dlmfs_get_inode(struct inode
*parent
,
349 struct dentry
*dentry
,
352 struct super_block
*sb
= parent
->i_sb
;
353 struct inode
* inode
= new_inode(sb
);
354 struct dlmfs_inode_private
*ip
;
359 inode
->i_mode
= mode
;
360 inode
->i_uid
= current
->fsuid
;
361 inode
->i_gid
= current
->fsgid
;
363 inode
->i_mapping
->backing_dev_info
= &dlmfs_backing_dev_info
;
364 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
367 ip
->ip_dlm
= DLMFS_I(parent
)->ip_dlm
;
369 switch (mode
& S_IFMT
) {
371 /* for now we don't support anything other than
372 * directories and regular files. */
376 inode
->i_op
= &dlmfs_file_inode_operations
;
377 inode
->i_fop
= &dlmfs_file_operations
;
379 i_size_write(inode
, DLM_LVB_LEN
);
381 user_dlm_lock_res_init(&ip
->ip_lockres
, dentry
);
383 /* released at clear_inode time, this insures that we
384 * get to drop the dlm reference on each lock *before*
385 * we call the unregister code for releasing parent
387 ip
->ip_parent
= igrab(parent
);
388 BUG_ON(!ip
->ip_parent
);
391 inode
->i_op
= &dlmfs_dir_inode_operations
;
392 inode
->i_fop
= &simple_dir_operations
;
394 /* directory inodes start off with i_nlink ==
395 * 2 (for "." entry) */
400 if (parent
->i_mode
& S_ISGID
) {
401 inode
->i_gid
= parent
->i_gid
;
403 inode
->i_mode
|= S_ISGID
;
410 * File creation. Allocate an inode, and we're done..
413 static int dlmfs_mkdir(struct inode
* dir
,
414 struct dentry
* dentry
,
418 struct inode
*inode
= NULL
;
419 struct qstr
*domain
= &dentry
->d_name
;
420 struct dlmfs_inode_private
*ip
;
421 struct dlm_ctxt
*dlm
;
423 mlog(0, "mkdir %.*s\n", domain
->len
, domain
->name
);
425 /* verify that we have a proper domain */
426 if (domain
->len
>= O2NM_MAX_NAME_LEN
) {
428 mlog(ML_ERROR
, "invalid domain name for directory.\n");
432 inode
= dlmfs_get_inode(dir
, dentry
, mode
| S_IFDIR
);
441 dlm
= user_dlm_register_context(domain
);
443 status
= PTR_ERR(dlm
);
444 mlog(ML_ERROR
, "Error %d could not register domain \"%.*s\"\n",
445 status
, domain
->len
, domain
->name
);
451 d_instantiate(dentry
, inode
);
452 dget(dentry
); /* Extra count - pin the dentry in core */
461 static int dlmfs_create(struct inode
*dir
,
462 struct dentry
*dentry
,
464 struct nameidata
*nd
)
468 struct qstr
*name
= &dentry
->d_name
;
470 mlog(0, "create %.*s\n", name
->len
, name
->name
);
472 /* verify name is valid and doesn't contain any dlm reserved
474 if (name
->len
>= USER_DLM_LOCK_ID_MAX_LEN
||
475 name
->name
[0] == '$') {
477 mlog(ML_ERROR
, "invalid lock name, %.*s\n", name
->len
,
482 inode
= dlmfs_get_inode(dir
, dentry
, mode
| S_IFREG
);
489 d_instantiate(dentry
, inode
);
490 dget(dentry
); /* Extra count - pin the dentry in core */
495 static int dlmfs_unlink(struct inode
*dir
,
496 struct dentry
*dentry
)
499 struct inode
*inode
= dentry
->d_inode
;
501 mlog(0, "unlink inode %lu\n", inode
->i_ino
);
503 /* if there are no current holders, or none that are waiting
504 * to acquire a lock, this basically destroys our lockres. */
505 status
= user_dlm_destroy_lock(&DLMFS_I(inode
)->ip_lockres
);
507 mlog(ML_ERROR
, "unlink %.*s, error %d from destroy\n",
508 dentry
->d_name
.len
, dentry
->d_name
.name
, status
);
511 status
= simple_unlink(dir
, dentry
);
516 static int dlmfs_fill_super(struct super_block
* sb
,
520 struct inode
* inode
;
521 struct dentry
* root
;
523 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
524 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
525 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
526 sb
->s_magic
= DLMFS_MAGIC
;
527 sb
->s_op
= &dlmfs_ops
;
528 inode
= dlmfs_get_root_inode(sb
);
532 root
= d_alloc_root(inode
);
541 static const struct file_operations dlmfs_file_operations
= {
542 .open
= dlmfs_file_open
,
543 .release
= dlmfs_file_release
,
544 .read
= dlmfs_file_read
,
545 .write
= dlmfs_file_write
,
548 static const struct inode_operations dlmfs_dir_inode_operations
= {
549 .create
= dlmfs_create
,
550 .lookup
= simple_lookup
,
551 .unlink
= dlmfs_unlink
,
554 /* this way we can restrict mkdir to only the toplevel of the fs. */
555 static const struct inode_operations dlmfs_root_inode_operations
= {
556 .lookup
= simple_lookup
,
557 .mkdir
= dlmfs_mkdir
,
558 .rmdir
= simple_rmdir
,
561 static const struct super_operations dlmfs_ops
= {
562 .statfs
= simple_statfs
,
563 .alloc_inode
= dlmfs_alloc_inode
,
564 .destroy_inode
= dlmfs_destroy_inode
,
565 .clear_inode
= dlmfs_clear_inode
,
566 .drop_inode
= generic_delete_inode
,
569 static const struct inode_operations dlmfs_file_inode_operations
= {
570 .getattr
= simple_getattr
,
573 static int dlmfs_get_sb(struct file_system_type
*fs_type
,
574 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
576 return get_sb_nodev(fs_type
, flags
, data
, dlmfs_fill_super
, mnt
);
579 static struct file_system_type dlmfs_fs_type
= {
580 .owner
= THIS_MODULE
,
581 .name
= "ocfs2_dlmfs",
582 .get_sb
= dlmfs_get_sb
,
583 .kill_sb
= kill_litter_super
,
586 static int __init
init_dlmfs_fs(void)
589 int cleanup_inode
= 0, cleanup_worker
= 0;
591 dlmfs_print_version();
593 dlmfs_inode_cache
= kmem_cache_create("dlmfs_inode_cache",
594 sizeof(struct dlmfs_inode_private
),
595 0, (SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|
597 dlmfs_init_once
, NULL
);
598 if (!dlmfs_inode_cache
)
602 user_dlm_worker
= create_singlethread_workqueue("user_dlm");
603 if (!user_dlm_worker
) {
609 status
= register_filesystem(&dlmfs_fs_type
);
613 kmem_cache_destroy(dlmfs_inode_cache
);
615 destroy_workqueue(user_dlm_worker
);
617 printk("OCFS2 User DLM kernel interface loaded\n");
621 static void __exit
exit_dlmfs_fs(void)
623 unregister_filesystem(&dlmfs_fs_type
);
625 flush_workqueue(user_dlm_worker
);
626 destroy_workqueue(user_dlm_worker
);
628 kmem_cache_destroy(dlmfs_inode_cache
);
631 MODULE_AUTHOR("Oracle");
632 MODULE_LICENSE("GPL");
634 module_init(init_dlmfs_fs
)
635 module_exit(exit_dlmfs_fs
)