Whamcloud - gitweb
be1320461c9834f93b38f07346f9e2c87f664754
[fs/lustre-release.git] / lustre / obdclass / genops.c
1 /*
2  *  linux/fs/ext2_obd/sim_obd.c
3  *
4  * These are the only exported functions; they provide the simulated object-
5  * oriented disk.
6  *
7  */
8
9 #include <linux/config.h>
10 #include <linux/kernel.h>
11 #include <linux/mm.h>
12 #include <linux/string.h>
13 #include <linux/stat.h>
14 #include <linux/errno.h>
15 #include <linux/locks.h>
16 #include <linux/unistd.h>
17
18 #include <asm/system.h>
19 #include <asm/uaccess.h>
20
21 #include <linux/fs.h>
22 #include <linux/stat.h>
23 #include <asm/uaccess.h>
24 #include <linux/vmalloc.h>
25 #include <asm/segment.h>
26 #include <linux/mm.h>
27 #include <linux/pagemap.h>
28 #include <linux/smp_lock.h>
29
30 #include <linux/obd_support.h>
31 #include <linux/obd_class.h>
32
33
34 extern struct obd_device obd_dev[MAX_OBD_DEVICES];
35 kmem_cache_t *obdo_cachep;
36
37 int obd_init_obdo_cache(void)
38 {
39         /* XXX need to free this somewhere? */
40         ENTRY;
41         obdo_cachep = kmem_cache_create("obdo_cache",
42                                               sizeof(struct obdo),
43                                               0, SLAB_HWCACHE_ALIGN,
44                                               NULL, NULL);
45         if (obdo_cachep == NULL) {
46                 EXIT;
47                 return -ENOMEM;
48         }
49         EXIT;
50         return 0;
51 }
52
53
54 /* map connection to client */
55 struct obd_client *gen_client(struct obd_conn *conn)
56 {
57         struct obd_device * obddev = conn->oc_dev;
58         struct list_head * lh, * next;
59         struct obd_client * cli;
60
61         lh = next = &obddev->obd_gen_clients;
62         while ((lh = lh->next) != &obddev->obd_gen_clients) {
63                 cli = list_entry(lh, struct obd_client, cli_chain);
64                 
65                 if (cli->cli_id == conn->oc_id)
66                         return cli;
67         }
68
69         return NULL;
70 } /* obd_client */
71
72
73
74 /* a connection defines a context in which preallocation can be managed. */ 
75 int gen_connect (struct obd_conn *conn)
76 {
77         struct obd_client * cli;
78
79         OBD_ALLOC(cli, struct obd_client *, sizeof(struct obd_client));
80         if ( !cli ) {
81                 printk("obd_connect (minor %d): no memory!\n", 
82                        conn->oc_dev->obd_minor);
83                 return -ENOMEM;
84         }
85
86         INIT_LIST_HEAD(&cli->cli_prealloc_inodes);
87         /* this should probably spinlocked? */
88         cli->cli_id = ++conn->oc_dev->obd_gen_last_id;
89         cli->cli_prealloc_quota = 0;
90         cli->cli_obd = conn->oc_dev;
91         list_add(&(cli->cli_chain), conn->oc_dev->obd_gen_clients.prev);
92
93         CDEBUG(D_IOCTL, "connect: new ID %u\n", cli->cli_id);
94         conn->oc_id = cli->cli_id;
95         return 0;
96 } /* gen_obd_connect */
97
98
99 int gen_disconnect(struct obd_conn *conn)
100 {
101         struct obd_client * cli;
102         ENTRY;
103
104         if (!(cli = gen_client(conn))) {
105                 CDEBUG(D_IOCTL, "disconnect: attempting to free "
106                        "nonexistent client %u\n", conn->oc_id);
107                 return -EINVAL;
108         }
109
110
111         list_del(&(cli->cli_chain));
112         OBD_FREE(cli, sizeof(struct obd_client));
113
114         CDEBUG(D_IOCTL, "disconnect: ID %u\n", conn->oc_id);
115
116         EXIT;
117         return 0;
118 } /* gen_obd_disconnect */
119
120
121 /* 
122  *   raid1 defines a number of connections to child devices,
123  *   used to make calls to these devices.
124  *   data holds nothing
125  */ 
126 int gen_multi_setup(struct obd_device *obddev, uint32_t len, void *data)
127 {
128         int i;
129
130         for (i = 0 ; i < obddev->obd_multi_count ; i++ ) {
131                 int rc;
132                 struct obd_conn *ch_conn = &obddev->obd_multi_conn[i];
133                 rc  = OBP(ch_conn->oc_dev, connect)(ch_conn);
134
135                 if ( rc != 0 ) {
136                         /* XXX disconnect others */
137                         return -EINVAL;
138                 }
139         }               
140         return 0;
141 }
142
143
144 #if 0
145 int gen_multi_attach(struct obd_device *obddev, int len, void *data)
146 {
147         int i;
148         int count;
149         struct obd_device *rdev = obddev->obd_multi_dev[0];
150
151         count = len/sizeof(int);
152         obddev->obd_multi_count = count;
153         for (i=0 ; i<count ; i++) {
154                 rdev = &obd_dev[*((int *)data + i)];
155                 rdev = rdev + 1;
156                 CDEBUG(D_IOCTL, "OBD RAID1: replicator %d is of type %s\n", i,
157                        (rdev + i)->obd_type->typ_name);
158         }
159         return 0;
160 }
161 #endif
162
163
164 /*
165  *    remove all connections to this device
166  *    close all connections to lower devices
167  *    needed for forced unloads of OBD client drivers
168  */
169 int gen_multi_cleanup(struct obd_device *obddev)
170 {
171         int i;
172
173         for (i = 0 ; i < obddev->obd_multi_count ; i++ ) {
174                 struct obd_conn *ch_conn = &obddev->obd_multi_conn[i];
175                 int rc;
176                 rc  = OBP(ch_conn->oc_dev, disconnect)(ch_conn);
177
178                 if ( rc != 0 ) {
179                         printk("OBD multi cleanup dev: disconnect failure %d\n", ch_conn->oc_dev->obd_minor);
180                 }
181         }               
182         return 0;
183 } /* gen_multi_cleanup_device */
184
185
186 /*
187  *    forced cleanup of the device:
188  *    - remove connections from the device
189  *    - cleanup the device afterwards
190  */
191 int gen_cleanup(struct obd_device * obddev)
192 {
193         struct list_head * lh, * tmp;
194         struct obd_client * cli;
195
196         ENTRY;
197
198         lh = tmp = &obddev->obd_gen_clients;
199         while ((tmp = tmp->next) != lh) {
200                 cli = list_entry(tmp, struct obd_client, cli_chain);
201                 CDEBUG(D_IOCTL, "Disconnecting obd_connection %d, at %p\n",
202                        cli->cli_id, cli);
203         }
204         return 0;
205 } /* sim_cleanup_device */
206
207 void ___wait_on_page(struct page *page)
208 {
209         struct task_struct *tsk = current;
210         DECLARE_WAITQUEUE(wait, tsk);
211
212         add_wait_queue(&page->wait, &wait);
213         do {
214                 run_task_queue(&tq_disk);
215                 set_task_state(tsk, TASK_UNINTERRUPTIBLE);
216                 if (!PageLocked(page))
217                         break;
218                 schedule();
219         } while (PageLocked(page));
220         tsk->state = TASK_RUNNING;
221         remove_wait_queue(&page->wait, &wait);
222 }
223
224 void lck_page(struct page *page)
225 {
226         while (TryLockPage(page))
227                 ___wait_on_page(page);
228 }
229
230 /* XXX this should return errors correctly, so should migrate!!! */
231 int gen_copy_data(struct obd_conn *dst_conn, struct obdo *dst,
232                   struct obd_conn *src_conn, struct obdo *src)
233 {
234         struct page *page;
235         unsigned long index = 0;
236         int rc;
237         ENTRY;
238
239         CDEBUG(D_INODE, "src: ino %Ld blocks %Ld, size %Ld, dst: ino %Ld\n", 
240                src->o_id, src->o_blocks, src->o_size, dst->o_id);
241         page = alloc_page(GFP_USER);
242         if ( !page ) {
243                 EXIT;
244                 return -ENOMEM;
245         }
246         
247         lck_page(page);
248         
249         while (index < ((src->o_size + PAGE_SIZE - 1) >> PAGE_SHIFT)) {
250                 
251                 page->index = index;
252                 rc = OBP(src_conn->oc_dev, brw)
253                         (READ, src_conn, src, (char *)page_address(page), 
254                          PAGE_SIZE, (page->index) << PAGE_SHIFT, 0);
255
256                 if ( rc != PAGE_SIZE ) 
257                         break;
258                 CDEBUG(D_INODE, "Read page %ld ...\n", page->index);
259
260                 rc = OBP(dst_conn->oc_dev, brw)
261                         (WRITE, dst_conn, dst,  (char *)page_address(page), 
262                          PAGE_SIZE, (page->index) << PAGE_SHIFT, 1);
263                 if ( rc != PAGE_SIZE)
264                         break;
265
266                 CDEBUG(D_INODE, "Wrote page %ld ...\n", page->index);
267                 
268                 index ++;
269         }
270         dst->o_size = src->o_size;
271         dst->o_blocks = src->o_blocks;
272         UnlockPage(page);
273         __free_page(page);
274
275         EXIT;
276         return 0;
277 }