← Back to branch summary

~helenos-nicf/helenos/nicf

« back to all changes in this revision

Viewing changes to uspace/srv/bd/part/mbr_part/mbr_part.c

  • Committer: Radim Vansa
  • Date: 2011-09-20 21:55:59 UTC
  • mfrom: (697.1.517 HelenOS.mainline)
  • Revision ID: radim.vansa@matfyz.cz-20110920215559-7fjpai6wt5ieurcq
Merge with mainline

Show diffs side-by-side

added added

removed removed

Lines of Context:
uspace/srv/bd/part/mbr_part/mbr_part.c
60
60
#include <async.h>
61
61
#include <as.h>
62
62
#include <fibril_synch.h>
63
 
#include <devmap.h>
 
63
#include <loc.h>
64
64
#include <sys/types.h>
65
65
#include <sys/typefmt.h>
66
66
#include <inttypes.h>
67
67
#include <libblock.h>
68
 
#include <devmap.h>
69
68
#include <errno.h>
70
69
#include <bool.h>
71
70
#include <byteorder.h>
99
98
        /** Number of blocks */
100
99
        aoff64_t length;
101
100
        /** Device representing the partition (outbound device) */
102
 
        devmap_handle_t dev;
 
101
        service_id_t dsid;
103
102
        /** Points to next partition structure. */
104
103
        struct part *next;
105
104
} part_t;
140
139
static size_t block_size;
141
140
 
142
141
/** Partitioned device (inbound device) */
143
 
static devmap_handle_t indev_handle;
 
142
static service_id_t indef_sid;
144
143
 
145
144
/** List of partitions. This structure is an empty head. */
146
145
static part_t plist_head;
149
148
static int mbr_part_read(void);
150
149
static part_t *mbr_part_new(void);
151
150
static void mbr_pte_to_part(uint32_t base, const pt_entry_t *pte, part_t *part);
152
 
static void mbr_connection(ipc_callid_t iid, ipc_call_t *icall);
 
151
static void mbr_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
153
152
static int mbr_bd_read(part_t *p, uint64_t ba, size_t cnt, void *buf);
154
153
static int mbr_bd_write(part_t *p, uint64_t ba, size_t cnt, const void *buf);
155
154
static int mbr_bsa_translate(part_t *p, uint64_t ba, size_t cnt, uint64_t *gba);
179
178
        int rc;
180
179
        int i;
181
180
        char *name;
182
 
        devmap_handle_t dev;
 
181
        service_id_t dsid;
183
182
        uint64_t size_mb;
184
183
        part_t *part;
185
184
 
186
 
        rc = devmap_device_get_handle(dev_name, &indev_handle, 0);
 
185
        rc = loc_service_get_id(dev_name, &indef_sid, 0);
187
186
        if (rc != EOK) {
188
187
                printf(NAME ": could not resolve device `%s'.\n", dev_name);
189
188
                return rc;
190
189
        }
191
190
 
192
 
        rc = block_init(indev_handle, 2048);
 
191
        rc = block_init(EXCHANGE_SERIALIZE, indef_sid, 2048);
193
192
        if (rc != EOK)  {
194
193
                printf(NAME ": could not init libblock.\n");
195
194
                return rc;
197
196
 
198
197
        /* Determine and verify block size. */
199
198
 
200
 
        rc = block_get_bsize(indev_handle, &block_size);
 
199
        rc = block_get_bsize(indef_sid, &block_size);
201
200
        if (rc != EOK) {
202
201
                printf(NAME ": error getting block size.\n");
203
202
                return rc;
213
212
        if (rc != EOK)
214
213
                return rc;
215
214
 
216
 
        /* Register the driver with device mapper. */
217
 
        rc = devmap_driver_register(NAME, mbr_connection);
 
215
        /* Register server with location service. */
 
216
        rc = loc_server_register(NAME, mbr_connection);
218
217
        if (rc != EOK) {
219
 
                printf(NAME ": Unable to register driver.\n");
 
218
                printf(NAME ": Unable to register server.\n");
220
219
                return rc;
221
220
        }
222
221
 
238
237
                if (name == NULL)
239
238
                        return ENOMEM;
240
239
 
241
 
                rc = devmap_device_register(name, &dev);
 
240
                rc = loc_service_register(name, &dsid);
242
241
                if (rc != EOK) {
243
 
                        printf(NAME ": Unable to register device %s.\n", name);
 
242
                        printf(NAME ": Unable to register service %s.\n", name);
244
243
                        return rc;
245
244
                }
246
245
 
249
248
                printf(NAME ": Registered device %s: %" PRIuOFF64 " blocks "
250
249
                    "%" PRIu64 " MB.\n", name, part->length, size_mb);
251
250
 
252
 
                part->dev = dev;
 
251
                part->dsid = dsid;
253
252
                free(name);
254
253
 
255
254
                part = part->next;
280
279
         * Read primary partition entries.
281
280
         */
282
281
 
283
 
        rc = block_read_direct(indev_handle, 0, 1, brb);
 
282
        rc = block_read_direct(indef_sid, 0, 1, brb);
284
283
        if (rc != EOK) {
285
284
                printf(NAME ": Failed reading MBR block.\n");
286
285
                return rc;
331
330
                 * of the extended partition.
332
331
                 */
333
332
                ba = cp.start_addr;
334
 
                rc = block_read_direct(indev_handle, ba, 1, brb);
 
333
                rc = block_read_direct(indef_sid, ba, 1, brb);
335
334
                if (rc != EOK) {
336
335
                        printf(NAME ": Failed reading EBR block at %"
337
336
                            PRIu32 ".\n", ba);
380
379
 
381
380
        part->present = (pte->ptype != PT_UNUSED) ? true : false;
382
381
 
383
 
        part->dev = 0;
 
382
        part->dsid = 0;
384
383
        part->next = NULL;
385
384
}
386
385
 
387
 
static void mbr_connection(ipc_callid_t iid, ipc_call_t *icall)
 
386
static void mbr_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
388
387
{
389
388
        size_t comm_size;
390
389
        void *fs_va = NULL;
391
390
        ipc_callid_t callid;
392
391
        ipc_call_t call;
393
392
        sysarg_t method;
394
 
        devmap_handle_t dh;
 
393
        service_id_t dh;
395
394
        unsigned int flags;
396
395
        int retval;
397
396
        uint64_t ba;
407
406
         * once for each connection.
408
407
         */
409
408
        part = plist_head.next;
410
 
        while (part != NULL && part->dev != dh)
 
409
        while (part != NULL && part->dsid != dh)
411
410
                part = part->next;
412
411
 
413
412
        if (part == NULL) {
436
435
        while (1) {
437
436
                callid = async_get_call(&call);
438
437
                method = IPC_GET_IMETHOD(call);
439
 
                switch (method) {
440
 
                case IPC_M_PHONE_HUNGUP:
 
438
                
 
439
                if (!method) {
441
440
                        /* The other side has hung up. */
442
441
                        async_answer_0(callid, EOK);
443
442
                        return;
 
443
                }
 
444
                
 
445
                switch (method) {
444
446
                case BD_READ_BLOCKS:
445
447
                        ba = MERGE_LOUP32(IPC_GET_ARG1(call),
446
448
                            IPC_GET_ARG2(call));
484
486
        if (mbr_bsa_translate(p, ba, cnt, &gba) != EOK)
485
487
                return ELIMIT;
486
488
 
487
 
        return block_read_direct(indev_handle, gba, cnt, buf);
 
489
        return block_read_direct(indef_sid, gba, cnt, buf);
488
490
}
489
491
 
490
492
/** Write blocks to partition. */
495
497
        if (mbr_bsa_translate(p, ba, cnt, &gba) != EOK)
496
498
                return ELIMIT;
497
499
 
498
 
        return block_write_direct(indev_handle, gba, cnt, buf);
 
500
        return block_write_direct(indef_sid, gba, cnt, buf);
499
501
}
500
502
 
501
503
/** Translate block segment address with range checking. */