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(struct kmem_cache
*cachep
,
261 struct dlmfs_inode_private
*ip
=
262 (struct dlmfs_inode_private
*) foo
;
265 ip
->ip_parent
= NULL
;
267 inode_init_once(&ip
->ip_vfs_inode
);
270 static struct inode
*dlmfs_alloc_inode(struct super_block
*sb
)
272 struct dlmfs_inode_private
*ip
;
274 ip
= kmem_cache_alloc(dlmfs_inode_cache
, GFP_NOFS
);
278 return &ip
->ip_vfs_inode
;
281 static void dlmfs_destroy_inode(struct inode
*inode
)
283 kmem_cache_free(dlmfs_inode_cache
, DLMFS_I(inode
));
286 static void dlmfs_clear_inode(struct inode
*inode
)
289 struct dlmfs_inode_private
*ip
;
294 mlog(0, "inode %lu\n", inode
->i_ino
);
298 if (S_ISREG(inode
->i_mode
)) {
299 status
= user_dlm_destroy_lock(&ip
->ip_lockres
);
306 mlog(0, "we're a directory, ip->ip_dlm = 0x%p\n", ip
->ip_dlm
);
307 /* we must be a directory. If required, lets unregister the
308 * dlm context now. */
310 user_dlm_unregister_context(ip
->ip_dlm
);
312 ip
->ip_parent
= NULL
;
316 static struct backing_dev_info dlmfs_backing_dev_info
= {
317 .ra_pages
= 0, /* No readahead */
318 .capabilities
= BDI_CAP_NO_ACCT_DIRTY
| BDI_CAP_NO_WRITEBACK
,
321 static struct inode
*dlmfs_get_root_inode(struct super_block
*sb
)
323 struct inode
*inode
= new_inode(sb
);
324 int mode
= S_IFDIR
| 0755;
325 struct dlmfs_inode_private
*ip
;
330 inode
->i_mode
= mode
;
331 inode
->i_uid
= current
->fsuid
;
332 inode
->i_gid
= current
->fsgid
;
334 inode
->i_mapping
->backing_dev_info
= &dlmfs_backing_dev_info
;
335 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
338 inode
->i_fop
= &simple_dir_operations
;
339 inode
->i_op
= &dlmfs_root_inode_operations
;
345 static struct inode
*dlmfs_get_inode(struct inode
*parent
,
346 struct dentry
*dentry
,
349 struct super_block
*sb
= parent
->i_sb
;
350 struct inode
* inode
= new_inode(sb
);
351 struct dlmfs_inode_private
*ip
;
356 inode
->i_mode
= mode
;
357 inode
->i_uid
= current
->fsuid
;
358 inode
->i_gid
= current
->fsgid
;
360 inode
->i_mapping
->backing_dev_info
= &dlmfs_backing_dev_info
;
361 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
364 ip
->ip_dlm
= DLMFS_I(parent
)->ip_dlm
;
366 switch (mode
& S_IFMT
) {
368 /* for now we don't support anything other than
369 * directories and regular files. */
373 inode
->i_op
= &dlmfs_file_inode_operations
;
374 inode
->i_fop
= &dlmfs_file_operations
;
376 i_size_write(inode
, DLM_LVB_LEN
);
378 user_dlm_lock_res_init(&ip
->ip_lockres
, dentry
);
380 /* released at clear_inode time, this insures that we
381 * get to drop the dlm reference on each lock *before*
382 * we call the unregister code for releasing parent
384 ip
->ip_parent
= igrab(parent
);
385 BUG_ON(!ip
->ip_parent
);
388 inode
->i_op
= &dlmfs_dir_inode_operations
;
389 inode
->i_fop
= &simple_dir_operations
;
391 /* directory inodes start off with i_nlink ==
392 * 2 (for "." entry) */
397 if (parent
->i_mode
& S_ISGID
) {
398 inode
->i_gid
= parent
->i_gid
;
400 inode
->i_mode
|= S_ISGID
;
407 * File creation. Allocate an inode, and we're done..
410 static int dlmfs_mkdir(struct inode
* dir
,
411 struct dentry
* dentry
,
415 struct inode
*inode
= NULL
;
416 struct qstr
*domain
= &dentry
->d_name
;
417 struct dlmfs_inode_private
*ip
;
418 struct dlm_ctxt
*dlm
;
420 mlog(0, "mkdir %.*s\n", domain
->len
, domain
->name
);
422 /* verify that we have a proper domain */
423 if (domain
->len
>= O2NM_MAX_NAME_LEN
) {
425 mlog(ML_ERROR
, "invalid domain name for directory.\n");
429 inode
= dlmfs_get_inode(dir
, dentry
, mode
| S_IFDIR
);
438 dlm
= user_dlm_register_context(domain
);
440 status
= PTR_ERR(dlm
);
441 mlog(ML_ERROR
, "Error %d could not register domain \"%.*s\"\n",
442 status
, domain
->len
, domain
->name
);
448 d_instantiate(dentry
, inode
);
449 dget(dentry
); /* Extra count - pin the dentry in core */
458 static int dlmfs_create(struct inode
*dir
,
459 struct dentry
*dentry
,
461 struct nameidata
*nd
)
465 struct qstr
*name
= &dentry
->d_name
;
467 mlog(0, "create %.*s\n", name
->len
, name
->name
);
469 /* verify name is valid and doesn't contain any dlm reserved
471 if (name
->len
>= USER_DLM_LOCK_ID_MAX_LEN
||
472 name
->name
[0] == '$') {
474 mlog(ML_ERROR
, "invalid lock name, %.*s\n", name
->len
,
479 inode
= dlmfs_get_inode(dir
, dentry
, mode
| S_IFREG
);
486 d_instantiate(dentry
, inode
);
487 dget(dentry
); /* Extra count - pin the dentry in core */
492 static int dlmfs_unlink(struct inode
*dir
,
493 struct dentry
*dentry
)
496 struct inode
*inode
= dentry
->d_inode
;
498 mlog(0, "unlink inode %lu\n", inode
->i_ino
);
500 /* if there are no current holders, or none that are waiting
501 * to acquire a lock, this basically destroys our lockres. */
502 status
= user_dlm_destroy_lock(&DLMFS_I(inode
)->ip_lockres
);
504 mlog(ML_ERROR
, "unlink %.*s, error %d from destroy\n",
505 dentry
->d_name
.len
, dentry
->d_name
.name
, status
);
508 status
= simple_unlink(dir
, dentry
);
513 static int dlmfs_fill_super(struct super_block
* sb
,
517 struct inode
* inode
;
518 struct dentry
* root
;
520 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
521 sb
->s_blocksize
= PAGE_CACHE_SIZE
;
522 sb
->s_blocksize_bits
= PAGE_CACHE_SHIFT
;
523 sb
->s_magic
= DLMFS_MAGIC
;
524 sb
->s_op
= &dlmfs_ops
;
525 inode
= dlmfs_get_root_inode(sb
);
529 root
= d_alloc_root(inode
);
538 static const struct file_operations dlmfs_file_operations
= {
539 .open
= dlmfs_file_open
,
540 .release
= dlmfs_file_release
,
541 .read
= dlmfs_file_read
,
542 .write
= dlmfs_file_write
,
545 static const struct inode_operations dlmfs_dir_inode_operations
= {
546 .create
= dlmfs_create
,
547 .lookup
= simple_lookup
,
548 .unlink
= dlmfs_unlink
,
551 /* this way we can restrict mkdir to only the toplevel of the fs. */
552 static const struct inode_operations dlmfs_root_inode_operations
= {
553 .lookup
= simple_lookup
,
554 .mkdir
= dlmfs_mkdir
,
555 .rmdir
= simple_rmdir
,
558 static const struct super_operations dlmfs_ops
= {
559 .statfs
= simple_statfs
,
560 .alloc_inode
= dlmfs_alloc_inode
,
561 .destroy_inode
= dlmfs_destroy_inode
,
562 .clear_inode
= dlmfs_clear_inode
,
563 .drop_inode
= generic_delete_inode
,
566 static const struct inode_operations dlmfs_file_inode_operations
= {
567 .getattr
= simple_getattr
,
570 static int dlmfs_get_sb(struct file_system_type
*fs_type
,
571 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
573 return get_sb_nodev(fs_type
, flags
, data
, dlmfs_fill_super
, mnt
);
576 static struct file_system_type dlmfs_fs_type
= {
577 .owner
= THIS_MODULE
,
578 .name
= "ocfs2_dlmfs",
579 .get_sb
= dlmfs_get_sb
,
580 .kill_sb
= kill_litter_super
,
583 static int __init
init_dlmfs_fs(void)
586 int cleanup_inode
= 0, cleanup_worker
= 0;
588 dlmfs_print_version();
590 status
= bdi_init(&dlmfs_backing_dev_info
);
594 dlmfs_inode_cache
= kmem_cache_create("dlmfs_inode_cache",
595 sizeof(struct dlmfs_inode_private
),
596 0, (SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|
599 if (!dlmfs_inode_cache
)
603 user_dlm_worker
= create_singlethread_workqueue("user_dlm");
604 if (!user_dlm_worker
) {
610 status
= register_filesystem(&dlmfs_fs_type
);
614 kmem_cache_destroy(dlmfs_inode_cache
);
616 destroy_workqueue(user_dlm_worker
);
617 bdi_destroy(&dlmfs_backing_dev_info
);
619 printk("OCFS2 User DLM kernel interface loaded\n");
623 static void __exit
exit_dlmfs_fs(void)
625 unregister_filesystem(&dlmfs_fs_type
);
627 flush_workqueue(user_dlm_worker
);
628 destroy_workqueue(user_dlm_worker
);
630 kmem_cache_destroy(dlmfs_inode_cache
);
632 bdi_destroy(&dlmfs_backing_dev_info
);
635 MODULE_AUTHOR("Oracle");
636 MODULE_LICENSE("GPL");
638 module_init(init_dlmfs_fs
)
639 module_exit(exit_dlmfs_fs
)