Rev 4539 | Rev 4566 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 4539 | Rev 4551 | ||
---|---|---|---|
Line 283... | Line 283... | ||
283 | * @return Phone over which a multi-call request can be safely |
283 | * @return Phone over which a multi-call request can be safely |
284 | * sent. Return 0 if no phone was found. |
284 | * sent. Return 0 if no phone was found. |
285 | */ |
285 | */ |
286 | int vfs_grab_phone(fs_handle_t handle) |
286 | int vfs_grab_phone(fs_handle_t handle) |
287 | { |
287 | { |
- | 288 | int phone; |
|
- | 289 | ||
288 | /* |
290 | /* |
289 | * For now, we don't try to be very clever and very fast. |
291 | * For now, we don't try to be very clever and very fast. We simply |
290 | * We simply lookup the phone in the fs_head list. We currently don't |
292 | * lookup the phone in the fs_head list and duplicate it. The duplicate |
291 | * open any additional phones (even though that itself would be pretty |
293 | * phone will be returned to the client and the client will use it for |
292 | * straightforward; housekeeping multiple open phones to a FS task would |
- | |
293 | * be more demanding). Instead, we simply take the respective |
294 | * communication. In the future, we should cache the connections so |
294 | * phone_futex and keep it until vfs_release_phone(). |
295 | * that they do not have to be reestablished over and over again. |
295 | */ |
296 | */ |
296 | fibril_mutex_lock(&fs_head_lock); |
297 | fibril_mutex_lock(&fs_head_lock); |
297 | link_t *cur; |
298 | link_t *cur; |
298 | fs_info_t *fs; |
299 | fs_info_t *fs; |
299 | for (cur = fs_head.next; cur != &fs_head; cur = cur->next) { |
300 | for (cur = fs_head.next; cur != &fs_head; cur = cur->next) { |
300 | fs = list_get_instance(cur, fs_info_t, fs_link); |
301 | fs = list_get_instance(cur, fs_info_t, fs_link); |
301 | if (fs->fs_handle == handle) { |
302 | if (fs->fs_handle == handle) { |
302 | fibril_mutex_unlock(&fs_head_lock); |
303 | fibril_mutex_unlock(&fs_head_lock); |
303 | fibril_mutex_lock(&fs->phone_lock); |
304 | fibril_mutex_lock(&fs->phone_lock); |
- | 305 | phone = ipc_connect_me_to(fs->phone, 0, 0, 0); |
|
- | 306 | fibril_mutex_unlock(&fs->phone_lock); |
|
- | 307 | ||
- | 308 | assert(phone > 0); |
|
304 | return fs->phone; |
309 | return phone; |
305 | } |
310 | } |
306 | } |
311 | } |
307 | fibril_mutex_unlock(&fs_head_lock); |
312 | fibril_mutex_unlock(&fs_head_lock); |
308 | return 0; |
313 | return 0; |
309 | } |
314 | } |
310 | 315 | ||
311 | /** Tell VFS that the phone is in use for any request. |
316 | /** Tell VFS that the phone is not needed anymore. |
312 | * |
317 | * |
313 | * @param phone Phone to FS task. |
318 | * @param phone Phone to FS task. |
314 | */ |
319 | */ |
315 | void vfs_release_phone(int phone) |
320 | void vfs_release_phone(int phone) |
316 | { |
321 | { |
317 | bool found = false; |
- | |
318 | - | ||
319 | fibril_mutex_lock(&fs_head_lock); |
- | |
320 | link_t *cur; |
- | |
321 | for (cur = fs_head.next; cur != &fs_head; cur = cur->next) { |
322 | /* TODO: implement connection caching */ |
322 | fs_info_t *fs = list_get_instance(cur, fs_info_t, fs_link); |
- | |
323 | if (fs->phone == phone) { |
323 | ipc_hangup(phone); |
324 | found = true; |
- | |
325 | fibril_mutex_unlock(&fs_head_lock); |
- | |
326 | fibril_mutex_unlock(&fs->phone_lock); |
- | |
327 | return; |
- | |
328 | } |
- | |
329 | } |
- | |
330 | fibril_mutex_unlock(&fs_head_lock); |
- | |
331 | - | ||
332 | /* |
- | |
333 | * Not good to get here. |
- | |
334 | */ |
- | |
335 | assert(found == true); |
- | |
336 | } |
324 | } |
337 | 325 | ||
338 | /** Convert file system name to its handle. |
326 | /** Convert file system name to its handle. |
339 | * |
327 | * |
340 | * @param name File system name. |
328 | * @param name File system name. |