Subversion Repositories HelenOS

Rev

Rev 4549 | Rev 4553 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3521 jermar 1
/*
2
 * Copyright (c) 2008 Jakub Jermar
3
 * Copyright (c) 2008 Martin Decky
4
 * All rights reserved.
5
 *
6
 * Redistribution and use in source and binary forms, with or without
7
 * modification, are permitted provided that the following conditions
8
 * are met:
9
 *
10
 * - Redistributions of source code must retain the above copyright
11
 *   notice, this list of conditions and the following disclaimer.
12
 * - Redistributions in binary form must reproduce the above copyright
13
 *   notice, this list of conditions and the following disclaimer in the
14
 *   documentation and/or other materials provided with the distribution.
15
 * - The name of the author may not be used to endorse or promote products
16
 *   derived from this software without specific prior written permission.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
 */
29
 
4001 decky 30
/** @addtogroup libblock
3521 jermar 31
 * @{
4001 decky 32
 */
3521 jermar 33
/**
34
 * @file
35
 * @brief
36
 */
37
 
4001 decky 38
#include "libblock.h"
3521 jermar 39
#include "../../srv/vfs/vfs.h"
3530 jermar 40
#include <ipc/devmap.h>
4400 svoboda 41
#include <ipc/bd.h>
3530 jermar 42
#include <ipc/services.h>
3521 jermar 43
#include <errno.h>
3530 jermar 44
#include <sys/mman.h>
3521 jermar 45
#include <async.h>
46
#include <ipc/ipc.h>
47
#include <as.h>
48
#include <assert.h>
3531 jermar 49
#include <futex.h>
4509 decky 50
#include <adt/list.h>
51
#include <adt/hash_table.h>
4483 decky 52
#include <mem.h>
3521 jermar 53
 
3531 jermar 54
/** Lock protecting the device connection list */
55
static futex_t dcl_lock = FUTEX_INITIALIZER;
56
/** Device connection list head. */
57
static LIST_INITIALIZE(dcl_head);
3530 jermar 58
 
3539 jermar 59
#define CACHE_BUCKETS_LOG2      10
60
#define CACHE_BUCKETS           (1 << CACHE_BUCKETS_LOG2)
61
 
3531 jermar 62
typedef struct {
3539 jermar 63
    futex_t lock;
64
    size_t block_size;      /**< Block size. */
65
    unsigned block_count;       /**< Total number of blocks. */
66
    hash_table_t block_hash;
67
    link_t free_head;
68
} cache_t;
69
 
70
typedef struct {
3531 jermar 71
    link_t link;
4434 jermar 72
    dev_handle_t dev_handle;
3531 jermar 73
    int dev_phone;
74
    void *com_area;
75
    size_t com_size;
76
    void *bb_buf;
77
    off_t bb_off;
78
    size_t bb_size;
3539 jermar 79
    cache_t *cache;
3531 jermar 80
} devcon_t;
81
 
82
static devcon_t *devcon_search(dev_handle_t dev_handle)
83
{
84
    link_t *cur;
85
 
86
    futex_down(&dcl_lock);
87
    for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
88
        devcon_t *devcon = list_get_instance(cur, devcon_t, link);
89
        if (devcon->dev_handle == dev_handle) {
90
            futex_up(&dcl_lock);
91
            return devcon;
92
        }
93
    }
94
    futex_up(&dcl_lock);
95
    return NULL;
96
}
97
 
98
static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area,
3537 jermar 99
   size_t com_size)
3531 jermar 100
{
101
    link_t *cur;
102
    devcon_t *devcon;
103
 
104
    devcon = malloc(sizeof(devcon_t));
105
    if (!devcon)
106
        return ENOMEM;
107
 
108
    link_initialize(&devcon->link);
109
    devcon->dev_handle = dev_handle;
110
    devcon->dev_phone = dev_phone;
111
    devcon->com_area = com_area;
112
    devcon->com_size = com_size;
3537 jermar 113
    devcon->bb_buf = NULL;
114
    devcon->bb_off = 0;
115
    devcon->bb_size = 0;
3539 jermar 116
    devcon->cache = NULL;
3531 jermar 117
 
118
    futex_down(&dcl_lock);
119
    for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {
120
        devcon_t *d = list_get_instance(cur, devcon_t, link);
121
        if (d->dev_handle == dev_handle) {
122
            futex_up(&dcl_lock);
123
            free(devcon);
124
            return EEXIST;
125
        }
126
    }
127
    list_append(&devcon->link, &dcl_head);
128
    futex_up(&dcl_lock);
129
    return EOK;
130
}
131
 
132
static void devcon_remove(devcon_t *devcon)
133
{
134
    futex_down(&dcl_lock);
135
    list_remove(&devcon->link);
136
    futex_up(&dcl_lock);
137
}
138
 
3537 jermar 139
int block_init(dev_handle_t dev_handle, size_t com_size)
3530 jermar 140
{
141
    int rc;
3531 jermar 142
    int dev_phone;
143
    void *com_area;
144
 
145
    com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE,
3530 jermar 146
        MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
3531 jermar 147
    if (!com_area) {
3530 jermar 148
        return ENOMEM;
149
    }
150
 
4401 svoboda 151
    dev_phone = devmap_device_connect(dev_handle, IPC_FLAG_BLOCKING);
3530 jermar 152
    if (dev_phone < 0) {
3531 jermar 153
        munmap(com_area, com_size);
3530 jermar 154
        return dev_phone;
155
    }
156
 
3531 jermar 157
    rc = ipc_share_out_start(dev_phone, com_area,
3530 jermar 158
        AS_AREA_READ | AS_AREA_WRITE);
159
    if (rc != EOK) {
3531 jermar 160
            munmap(com_area, com_size);
3530 jermar 161
        ipc_hangup(dev_phone);
162
        return rc;
163
    }
3531 jermar 164
 
3537 jermar 165
    rc = devcon_add(dev_handle, dev_phone, com_area, com_size);
3531 jermar 166
    if (rc != EOK) {
167
        munmap(com_area, com_size);
168
        ipc_hangup(dev_phone);
169
        return rc;
170
    }
171
 
3530 jermar 172
    return EOK;
173
}
174
 
175
void block_fini(dev_handle_t dev_handle)
176
{
3531 jermar 177
    devcon_t *devcon = devcon_search(dev_handle);
178
    assert(devcon);
179
 
180
    devcon_remove(devcon);
181
 
3537 jermar 182
    if (devcon->bb_buf)
183
        free(devcon->bb_buf);
3539 jermar 184
 
185
    if (devcon->cache) {
186
        hash_table_destroy(&devcon->cache->block_hash);
187
        free(devcon->cache);
188
    }
189
 
3531 jermar 190
    munmap(devcon->com_area, devcon->com_size);
191
    ipc_hangup(devcon->dev_phone);
192
 
193
    free(devcon);  
3530 jermar 194
}
195
 
3537 jermar 196
int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size)
197
{
198
    void *bb_buf;
3538 jermar 199
    int rc;
3537 jermar 200
 
201
    devcon_t *devcon = devcon_search(dev_handle);
202
    if (!devcon)
203
        return ENOENT;
204
    if (devcon->bb_buf)
205
        return EEXIST;
206
    bb_buf = malloc(size);
207
    if (!bb_buf)
208
        return ENOMEM;
209
 
210
    off_t bufpos = 0;
211
    size_t buflen = 0;
3538 jermar 212
    rc = block_read(dev_handle, &bufpos, &buflen, &off,
213
        bb_buf, size, size);
214
    if (rc != EOK) {
3537 jermar 215
            free(bb_buf);
3538 jermar 216
        return rc;
3537 jermar 217
    }
218
    devcon->bb_buf = bb_buf;
219
    devcon->bb_off = off;
220
    devcon->bb_size = size;
221
 
222
    return EOK;
223
}
224
 
3530 jermar 225
void *block_bb_get(dev_handle_t dev_handle)
226
{
3531 jermar 227
    devcon_t *devcon = devcon_search(dev_handle);
228
    assert(devcon);
229
    return devcon->bb_buf;
3530 jermar 230
}
231
 
3539 jermar 232
static hash_index_t cache_hash(unsigned long *key)
233
{
234
    return *key & (CACHE_BUCKETS - 1);
235
}
236
 
237
static int cache_compare(unsigned long *key, hash_count_t keys, link_t *item)
238
{
239
    block_t *b = hash_table_get_instance(item, block_t, hash_link);
240
    return b->boff == *key;
241
}
242
 
243
static void cache_remove_callback(link_t *item)
244
{
245
}
246
 
247
static hash_table_operations_t cache_ops = {
248
    .hash = cache_hash,
249
    .compare = cache_compare,
250
    .remove_callback = cache_remove_callback
251
};
252
 
253
int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks)
254
{
255
    devcon_t *devcon = devcon_search(dev_handle);
256
    cache_t *cache;
257
    if (!devcon)
258
        return ENOENT;
259
    if (devcon->cache)
260
        return EEXIST;
261
    cache = malloc(sizeof(cache_t));
262
    if (!cache)
263
        return ENOMEM;
264
 
3540 jermar 265
    futex_initialize(&cache->lock, 1);
3539 jermar 266
    list_initialize(&cache->free_head);
267
    cache->block_size = size;
268
    cache->block_count = blocks;
269
 
270
    if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1,
271
        &cache_ops)) {
272
        free(cache);
273
        return ENOMEM;
274
    }
275
 
276
    devcon->cache = cache;
277
    return EOK;
278
}
279
 
3540 jermar 280
static bool cache_can_grow(cache_t *cache)
3521 jermar 281
{
3540 jermar 282
    return true;
283
}
284
 
285
static void block_initialize(block_t *b)
286
{
287
    futex_initialize(&b->lock, 1);
288
    b->refcnt = 1;
289
    b->dirty = false;
290
    rwlock_initialize(&b->contents_lock);
291
    link_initialize(&b->free_link);
292
    link_initialize(&b->hash_link);
293
}
294
 
295
/** Instantiate a block in memory and get a reference to it.
296
 *
297
 * @param dev_handle        Device handle of the block device.
298
 * @param boff          Block offset.
3595 jermar 299
 * @param flags         If BLOCK_FLAGS_NOREAD is specified, block_get()
300
 *              will not read the contents of the block from the
301
 *              device.
3540 jermar 302
 *
303
 * @return          Block structure.
304
 */
3595 jermar 305
block_t *block_get(dev_handle_t dev_handle, bn_t boff, int flags)
3540 jermar 306
{
307
    devcon_t *devcon;
308
    cache_t *cache;
3521 jermar 309
    block_t *b;
3540 jermar 310
    link_t *l;
311
    unsigned long key = boff;
312
 
313
    devcon = devcon_search(dev_handle);
3521 jermar 314
 
3540 jermar 315
    assert(devcon);
316
    assert(devcon->cache);
3521 jermar 317
 
3540 jermar 318
    cache = devcon->cache;
319
    futex_down(&cache->lock);
320
    l = hash_table_find(&cache->block_hash, &key);
321
    if (l) {
322
        /*
323
         * We found the block in the cache.
324
         */
325
        b = hash_table_get_instance(l, block_t, hash_link);
326
        futex_down(&b->lock);
327
        if (b->refcnt++ == 0)
328
            list_remove(&b->free_link);
329
        futex_up(&b->lock);
3544 jermar 330
        futex_up(&cache->lock);
3540 jermar 331
    } else {
332
        /*
333
         * The block was not found in the cache.
334
         */
335
        int rc;
336
        off_t bufpos = 0;
337
        size_t buflen = 0;
338
        off_t pos = boff * cache->block_size;
3544 jermar 339
        bool sync = false;
3521 jermar 340
 
3540 jermar 341
        if (cache_can_grow(cache)) {
342
            /*
343
             * We can grow the cache by allocating new blocks.
344
             * Should the allocation fail, we fail over and try to
345
             * recycle a block from the cache.
346
             */
347
            b = malloc(sizeof(block_t));
348
            if (!b)
349
                goto recycle;
350
            b->data = malloc(cache->block_size);
351
            if (!b->data) {
352
                free(b);
353
                goto recycle;
354
            }
355
        } else {
356
            /*
357
             * Try to recycle a block from the free list.
358
             */
359
            unsigned long temp_key;
360
recycle:
361
            assert(!list_empty(&cache->free_head));
362
            l = cache->free_head.next;
363
            list_remove(l);
364
            b = hash_table_get_instance(l, block_t, hash_link);
3544 jermar 365
            sync = b->dirty;
3540 jermar 366
            temp_key = b->boff;
367
            hash_table_remove(&cache->block_hash, &temp_key, 1);
368
        }
369
 
370
        block_initialize(b);
371
        b->dev_handle = dev_handle;
372
        b->size = cache->block_size;
373
        b->boff = boff;
3544 jermar 374
        hash_table_insert(&cache->block_hash, &key, &b->hash_link);
375
 
376
        /*
377
         * Lock the block before releasing the cache lock. Thus we don't
378
         * kill concurent operations on the cache while doing I/O on the
379
         * block.
380
         */
381
        futex_down(&b->lock);
382
        futex_up(&cache->lock);
383
 
384
        if (sync) {
385
            /*
386
             * The block is dirty and needs to be written back to
387
             * the device before we can read in the new contents.
388
             */
389
            abort();    /* TODO: block_write() */
390
        }
3595 jermar 391
        if (!(flags & BLOCK_FLAGS_NOREAD)) {
392
            /*
393
             * The block contains old or no data. We need to read
394
             * the new contents from the device.
395
             */
4550 jermar 396
            async_serialize_start();
3595 jermar 397
            rc = block_read(dev_handle, &bufpos, &buflen, &pos,
398
                b->data, cache->block_size, cache->block_size);
4550 jermar 399
            async_serialize_end();
3595 jermar 400
            assert(rc == EOK);
401
        }
3544 jermar 402
 
403
        futex_up(&b->lock);
3521 jermar 404
    }
405
    return b;
406
}
407
 
3543 jermar 408
/** Release a reference to a block.
409
 *
3544 jermar 410
 * If the last reference is dropped, the block is put on the free list.
3543 jermar 411
 *
412
 * @param block     Block of which a reference is to be released.
413
 */
3521 jermar 414
void block_put(block_t *block)
415
{
3543 jermar 416
    devcon_t *devcon = devcon_search(block->dev_handle);
417
    cache_t *cache;
418
 
419
    assert(devcon);
420
    assert(devcon->cache);
421
 
422
    cache = devcon->cache;
423
    futex_down(&cache->lock);
424
    futex_down(&block->lock);
425
    if (!--block->refcnt) {
426
        /*
427
         * Last reference to the block was dropped, put the block on the
428
         * free list.
429
         */
430
        list_append(&block->free_link, &cache->free_head);
431
    }
432
    futex_up(&block->lock);
3544 jermar 433
    futex_up(&cache->lock);
3543 jermar 434
}
435
 
436
/** Read data from a block device.
437
 *
438
 * @param dev_handle    Device handle of the block device.
439
 * @param bufpos    Pointer to the first unread valid offset within the
440
 *          communication buffer.
441
 * @param buflen    Pointer to the number of unread bytes that are ready in
442
 *          the communication buffer.
443
 * @param pos       Device position to be read.
444
 * @param dst       Destination buffer.
445
 * @param size      Size of the destination buffer.
446
 * @param block_size    Block size to be used for the transfer.
447
 *
448
 * @return      EOK on success or a negative return code on failure.
449
 */
450
int
4435 jermar 451
block_read(dev_handle_t dev_handle, off_t *bufpos, size_t *buflen, off_t *pos,
452
    void *dst, size_t size, size_t block_size)
3543 jermar 453
{
454
    off_t offset = 0;
455
    size_t left = size;
456
    devcon_t *devcon = devcon_search(dev_handle);
457
    assert(devcon);
3540 jermar 458
 
3543 jermar 459
    while (left > 0) {
460
        size_t rd;
461
 
462
        if (*bufpos + left < *buflen)
463
            rd = left;
464
        else
465
            rd = *buflen - *bufpos;
466
 
467
        if (rd > 0) {
468
            /*
469
             * Copy the contents of the communication buffer to the
470
             * destination buffer.
471
             */
472
            memcpy(dst + offset, devcon->com_area + *bufpos, rd);
473
            offset += rd;
474
            *bufpos += rd;
475
            *pos += rd;
476
            left -= rd;
477
        }
478
 
4549 svoboda 479
        if (*bufpos == (off_t) *buflen) {
3543 jermar 480
            /* Refill the communication buffer with a new block. */
481
            ipcarg_t retval;
4400 svoboda 482
            int rc = async_req_2_1(devcon->dev_phone, BD_READ_BLOCK,
3543 jermar 483
                *pos / block_size, block_size, &retval);
484
            if ((rc != EOK) || (retval != EOK))
4549 svoboda 485
                return (rc != EOK ? rc : (int) retval);
3543 jermar 486
 
487
            *bufpos = 0;
488
            *buflen = block_size;
489
        }
490
    }
491
 
492
    return EOK;
3521 jermar 493
}
494
 
495
/** @}
496
 */