[POWERPC] boot: Simplify gunzip_finish
[linux-2.6] / fs / gfs2 / locking.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/string.h>
13 #include <linux/slab.h>
14 #include <linux/wait.h>
15 #include <linux/sched.h>
16 #include <linux/kmod.h>
17 #include <linux/fs.h>
18 #include <linux/delay.h>
19 #include <linux/lm_interface.h>
20
21 struct lmh_wrapper {
22         struct list_head lw_list;
23         const struct lm_lockops *lw_ops;
24 };
25
26 /* List of registered low-level locking protocols.  A file system selects one
27    of them by name at mount time, e.g. lock_nolock, lock_dlm. */
28
29 static LIST_HEAD(lmh_list);
30 static DEFINE_MUTEX(lmh_lock);
31
32 /**
33  * gfs2_register_lockproto - Register a low-level locking protocol
34  * @proto: the protocol definition
35  *
36  * Returns: 0 on success, -EXXX on failure
37  */
38
39 int gfs2_register_lockproto(const struct lm_lockops *proto)
40 {
41         struct lmh_wrapper *lw;
42
43         mutex_lock(&lmh_lock);
44
45         list_for_each_entry(lw, &lmh_list, lw_list) {
46                 if (!strcmp(lw->lw_ops->lm_proto_name, proto->lm_proto_name)) {
47                         mutex_unlock(&lmh_lock);
48                         printk(KERN_INFO "GFS2: protocol %s already exists\n",
49                                proto->lm_proto_name);
50                         return -EEXIST;
51                 }
52         }
53
54         lw = kzalloc(sizeof(struct lmh_wrapper), GFP_KERNEL);
55         if (!lw) {
56                 mutex_unlock(&lmh_lock);
57                 return -ENOMEM;
58         }
59
60         lw->lw_ops = proto;
61         list_add(&lw->lw_list, &lmh_list);
62
63         mutex_unlock(&lmh_lock);
64
65         return 0;
66 }
67
68 /**
69  * gfs2_unregister_lockproto - Unregister a low-level locking protocol
70  * @proto: the protocol definition
71  *
72  */
73
74 void gfs2_unregister_lockproto(const struct lm_lockops *proto)
75 {
76         struct lmh_wrapper *lw;
77
78         mutex_lock(&lmh_lock);
79
80         list_for_each_entry(lw, &lmh_list, lw_list) {
81                 if (!strcmp(lw->lw_ops->lm_proto_name, proto->lm_proto_name)) {
82                         list_del(&lw->lw_list);
83                         mutex_unlock(&lmh_lock);
84                         kfree(lw);
85                         return;
86                 }
87         }
88
89         mutex_unlock(&lmh_lock);
90
91         printk(KERN_WARNING "GFS2: can't unregister lock protocol %s\n",
92                proto->lm_proto_name);
93 }
94
95 /**
96  * gfs2_mount_lockproto - Mount a lock protocol
97  * @proto_name - the name of the protocol
98  * @table_name - the name of the lock space
99  * @host_data - data specific to this host
100  * @cb - the callback to the code using the lock module
101  * @sdp - The GFS2 superblock
102  * @min_lvb_size - the mininum LVB size that the caller can deal with
103  * @flags - LM_MFLAG_*
104  * @lockstruct - a structure returned describing the mount
105  *
106  * Returns: 0 on success, -EXXX on failure
107  */
108
109 int gfs2_mount_lockproto(char *proto_name, char *table_name, char *host_data,
110                          lm_callback_t cb, void *cb_data,
111                          unsigned int min_lvb_size, int flags,
112                          struct lm_lockstruct *lockstruct,
113                          struct kobject *fskobj)
114 {
115         struct lmh_wrapper *lw = NULL;
116         int try = 0;
117         int error, found;
118
119 retry:
120         mutex_lock(&lmh_lock);
121
122         found = 0;
123         list_for_each_entry(lw, &lmh_list, lw_list) {
124                 if (!strcmp(lw->lw_ops->lm_proto_name, proto_name)) {
125                         found = 1;
126                         break;
127                 }
128         }
129
130         if (!found) {
131                 if (!try && capable(CAP_SYS_MODULE)) {
132                         try = 1;
133                         mutex_unlock(&lmh_lock);
134                         request_module(proto_name);
135                         goto retry;
136                 }
137                 printk(KERN_INFO "GFS2: can't find protocol %s\n", proto_name);
138                 error = -ENOENT;
139                 goto out;
140         }
141
142         if (!try_module_get(lw->lw_ops->lm_owner)) {
143                 try = 0;
144                 mutex_unlock(&lmh_lock);
145                 msleep(1000);
146                 goto retry;
147         }
148
149         error = lw->lw_ops->lm_mount(table_name, host_data, cb, cb_data,
150                                      min_lvb_size, flags, lockstruct, fskobj);
151         if (error)
152                 module_put(lw->lw_ops->lm_owner);
153 out:
154         mutex_unlock(&lmh_lock);
155         return error;
156 }
157
158 void gfs2_unmount_lockproto(struct lm_lockstruct *lockstruct)
159 {
160         mutex_lock(&lmh_lock);
161         lockstruct->ls_ops->lm_unmount(lockstruct->ls_lockspace);
162         if (lockstruct->ls_ops->lm_owner)
163                 module_put(lockstruct->ls_ops->lm_owner);
164         mutex_unlock(&lmh_lock);
165 }
166
167 /**
168  * gfs2_withdraw_lockproto - abnormally unmount a lock module
169  * @lockstruct: the lockstruct passed into mount
170  *
171  */
172
173 void gfs2_withdraw_lockproto(struct lm_lockstruct *lockstruct)
174 {
175         mutex_lock(&lmh_lock);
176         lockstruct->ls_ops->lm_withdraw(lockstruct->ls_lockspace);
177         if (lockstruct->ls_ops->lm_owner)
178                 module_put(lockstruct->ls_ops->lm_owner);
179         mutex_unlock(&lmh_lock);
180 }
181
182 EXPORT_SYMBOL_GPL(gfs2_register_lockproto);
183 EXPORT_SYMBOL_GPL(gfs2_unregister_lockproto);
184