Whamcloud - gitweb
- ext2_obd.c --- fix the bugs in read/write for Linux 2.4.3
[fs/lustre-release.git] / lustre / obdclass / genops.c
1 /*
2  *  linux/fs/ext2_obd/sim_obd.c
3  * Copyright (C) 2001  Cluster File Systems, Inc.
4  *
5  * This code is issued under the GNU General Public License.
6  * See the file COPYING in this distribution
7  *
8  * These are the only exported functions; they provide the simulated object-
9  * oriented disk.
10  *
11  */
12
13
14 #include <linux/mm.h>
15 #include <linux/fs.h>
16 #include <linux/sched.h>
17 #include <asm/uaccess.h>
18
19 #include <linux/obd_support.h>
20 #include <linux/obd_class.h>
21
22
23 extern struct obd_device obd_dev[MAX_OBD_DEVICES];
24 kmem_cache_t *obdo_cachep = NULL;
25
26 int obd_init_obdo_cache(void)
27 {
28         ENTRY;
29         if (obdo_cachep == NULL) {
30                 CDEBUG(D_CACHE, "allocating obdo_cache\n");
31                 obdo_cachep = kmem_cache_create("obdo_cache",
32                                                 sizeof(struct obdo),
33                                                 0, SLAB_HWCACHE_ALIGN,
34                                                 NULL, NULL);
35                 if (obdo_cachep == NULL) {
36                         EXIT;
37                         return -ENOMEM;
38                 } else {
39                         CDEBUG(D_CACHE, "allocated cache at %p\n", obdo_cachep);
40                 }
41         } else {
42                 CDEBUG(D_CACHE, "using existing cache at %p\n", obdo_cachep);
43         }
44         EXIT;
45         return 0;
46 }
47
48 void obd_cleanup_obdo_cache(void)
49 {
50         ENTRY;
51         if (obdo_cachep != NULL) {
52                 CDEBUG(D_CACHE, "destroying obdo_cache at %p\n", obdo_cachep);
53                 if (kmem_cache_destroy(obdo_cachep))
54                         printk(KERN_WARNING __FUNCTION__
55                                ": unable to free cache\n");
56         } else
57                 printk(KERN_INFO __FUNCTION__
58                        ": called with NULL cache pointer\n");
59
60         obdo_cachep = NULL;
61         EXIT;
62 }
63
64
65 /* map connection to client */
66 struct obd_client *gen_client(const struct obd_conn *conn)
67 {
68         struct obd_device * obddev = conn->oc_dev;
69         struct list_head * lh, * next;
70         struct obd_client * cli;
71
72         lh = next = &obddev->obd_gen_clients;
73         while ((lh = lh->next) != &obddev->obd_gen_clients) {
74                 cli = list_entry(lh, struct obd_client, cli_chain);
75                 
76                 if (cli->cli_id == conn->oc_id)
77                         return cli;
78         }
79
80         return NULL;
81 } /* obd_client */
82
83
84 /* a connection defines a context in which preallocation can be managed. */ 
85 int gen_connect (struct obd_conn *conn)
86 {
87         struct obd_client * cli;
88
89         OBD_ALLOC(cli, struct obd_client *, sizeof(struct obd_client));
90         if ( !cli ) {
91                 printk(__FUNCTION__ ": no memory! (minor %d)\n", 
92                        conn->oc_dev->obd_minor);
93                 return -ENOMEM;
94         }
95
96         INIT_LIST_HEAD(&cli->cli_prealloc_inodes);
97         /* XXX this should probably spinlocked? */
98         cli->cli_id = ++conn->oc_dev->obd_gen_last_id;
99         cli->cli_prealloc_quota = 0;
100         cli->cli_obd = conn->oc_dev;
101         list_add(&(cli->cli_chain), conn->oc_dev->obd_gen_clients.prev);
102
103         CDEBUG(D_INFO, "connect: new ID %u\n", cli->cli_id);
104         conn->oc_id = cli->cli_id;
105         return 0;
106 } /* gen_obd_connect */
107
108
109 int gen_disconnect(struct obd_conn *conn)
110 {
111         struct obd_client * cli;
112         ENTRY;
113
114         if (!(cli = gen_client(conn))) {
115                 CDEBUG(D_IOCTL, "disconnect: attempting to free "
116                        "nonexistent client %u\n", conn->oc_id);
117                 return -EINVAL;
118         }
119
120
121         list_del(&(cli->cli_chain));
122         OBD_FREE(cli, sizeof(struct obd_client));
123
124         CDEBUG(D_INFO, "disconnect: ID %u\n", conn->oc_id);
125
126         EXIT;
127         return 0;
128 } /* gen_obd_disconnect */
129
130
131 /* 
132  *   raid1 defines a number of connections to child devices,
133  *   used to make calls to these devices.
134  *   data holds nothing
135  */ 
136 int gen_multi_setup(struct obd_device *obddev, uint32_t len, void *data)
137 {
138         int i;
139
140         for (i = 0 ; i < obddev->obd_multi_count ; i++ ) {
141                 int rc;
142                 struct obd_conn *ch_conn = &obddev->obd_multi_conn[i];
143                 rc  = OBP(ch_conn->oc_dev, connect)(ch_conn);
144
145                 if ( rc != 0 ) {
146                         int j;
147
148                         for (j = --i; j >= 0; --j) {
149                                 ch_conn = &obddev->obd_multi_conn[i];
150                                 OBP(ch_conn->oc_dev, disconnect)(ch_conn);
151                         }
152                         return -EINVAL;
153                 }
154         }               
155         return 0;
156 }
157
158
159 #if 0
160 int gen_multi_attach(struct obd_device *obddev, int len, void *data)
161 {
162         int i;
163         int count;
164         struct obd_device *rdev = obddev->obd_multi_dev[0];
165
166         count = len/sizeof(int);
167         obddev->obd_multi_count = count;
168         for (i=0 ; i<count ; i++) {
169                 rdev = &obd_dev[*((int *)data + i)];
170                 rdev = rdev + 1;
171                 CDEBUG(D_INFO, "OBD RAID1: replicator %d is of type %s\n", i,
172                        (rdev + i)->obd_type->typ_name);
173         }
174         return 0;
175 }
176 #endif
177
178
179 /*
180  *    remove all connections to this device
181  *    close all connections to lower devices
182  *    needed for forced unloads of OBD client drivers
183  */
184 int gen_multi_cleanup(struct obd_device *obddev)
185 {
186         int i;
187
188         for (i = 0 ; i < obddev->obd_multi_count ; i++ ) {
189                 struct obd_conn *ch_conn = &obddev->obd_multi_conn[i];
190                 int rc;
191                 rc  = OBP(ch_conn->oc_dev, disconnect)(ch_conn);
192
193                 if ( rc != 0 ) {
194                         printk(KERN_WARNING __FUNCTION__
195                                ": disconnect failure %d\n",
196                                ch_conn->oc_dev->obd_minor);
197                 }
198         }               
199         return 0;
200 } /* gen_multi_cleanup_device */
201
202
203 /*
204  *    forced cleanup of the device:
205  *    - remove connections from the device
206  *    - cleanup the device afterwards
207  */
208 int gen_cleanup(struct obd_device * obddev)
209 {
210         struct list_head * lh, * tmp;
211         struct obd_client * cli;
212
213         ENTRY;
214
215         lh = tmp = &obddev->obd_gen_clients;
216         while ((tmp = tmp->next) != lh) {
217                 cli = list_entry(tmp, struct obd_client, cli_chain);
218                 CDEBUG(D_INFO, "Disconnecting obd_connection %d, at %p\n",
219                        cli->cli_id, cli);
220         }
221         return 0;
222 } /* sim_cleanup_device */
223
224 void ___wait_on_page(struct page *page)
225 {
226         struct task_struct *tsk = current;
227         DECLARE_WAITQUEUE(wait, tsk);
228
229         add_wait_queue(&page->wait, &wait);
230         do {
231                 run_task_queue(&tq_disk);
232                 set_task_state(tsk, TASK_UNINTERRUPTIBLE);
233                 if (!PageLocked(page))
234                         break;
235                 schedule();
236         } while (PageLocked(page));
237         tsk->state = TASK_RUNNING;
238         remove_wait_queue(&page->wait, &wait);
239 }
240
241 void lck_page(struct page *page)
242 {
243         while (TryLockPage(page))
244                 ___wait_on_page(page);
245 }
246
247 int gen_copy_data(struct obd_conn *dst_conn, struct obdo *dst,
248                   struct obd_conn *src_conn, struct obdo *src,
249                   obd_size count, obd_off offset)
250 {
251         struct page *page;
252         unsigned long index = 0;
253         int err = 0;
254
255         ENTRY;
256         CDEBUG(D_INFO, "src: ino %Ld blocks %Ld, size %Ld, dst: ino %Ld\n", 
257                src->o_id, src->o_blocks, src->o_size, dst->o_id);
258         page = alloc_page(GFP_USER);
259         if ( !page ) {
260                 EXIT;
261                 return -ENOMEM;
262         }
263         
264         lck_page(page);
265         
266         /* XXX with brw vector I/O, we could batch up reads and writes here,
267          *     all we need to do is allocate multiple pages to handle the I/Os
268          *     and arrays to handle the request parameters.
269          */
270         while (index < ((src->o_size + PAGE_SIZE - 1) >> PAGE_SHIFT)) {
271                 obd_count        num_oa = 1;
272                 obd_count        num_buf = 1;
273                 char            *buf;
274                 obd_size         brw_count = PAGE_SIZE;
275                 obd_off          brw_offset = (page->index) << PAGE_SHIFT;
276                 obd_flag         flagr = 0;
277                 obd_flag         flagw = OBD_BRW_CREATE;
278                 
279                 page->index = index;
280                 buf = (char *)page_address(page); 
281                 err = OBP(src_conn->oc_dev, brw)(READ, src_conn, num_oa, &src,
282                                                  &num_buf, &buf, &brw_count,
283                                                  &brw_offset, &flagr);
284
285                 if ( err ) {
286                         EXIT;
287                         break;
288                 }
289                 CDEBUG(D_INFO, "Read page %ld ...\n", page->index);
290
291                 err = OBP(dst_conn->oc_dev, brw)(WRITE, dst_conn, num_oa, &dst,
292                                                  &num_buf, &buf, &brw_count,
293                                                  &brw_offset, &flagw);
294
295                 /* XXX should handle dst->o_size, dst->o_blocks here */
296                 if ( err ) {
297                         EXIT;
298                         break;
299                 }
300
301                 CDEBUG(D_INFO, "Wrote page %ld ...\n", page->index);
302                 
303                 index++;
304         }
305         dst->o_size = src->o_size;
306         dst->o_blocks = src->o_blocks;
307         dst->o_valid |= (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS);
308         obd_unlock_page(page);
309         __free_page(page);
310
311         EXIT;
312         return err;
313 }