Changeset 903bac0a in mainline for uspace/app


Ignore:
Timestamp:
2011-08-19T09:00:38Z (15 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e2ab36f1
Parents:
d894fbd (diff), 42a619b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Location:
uspace/app
Files:
1 added
3 deleted
14 edited
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/app/bdsh/cmds/modules/bdd/bdd.c

    rd894fbd r903bac0a  
    3939
    4040#include <libblock.h>
    41 #include <devmap.h>
     41#include <loc.h>
    4242#include <errno.h>
    4343#include <assert.h>
    … …  
    6969        unsigned int argc;
    7070        unsigned int i, j;
    71         devmap_handle_t handle;
     71        service_id_t service_id;
    7272        aoff64_t offset;
    7373        uint8_t *blk;
    … …  
    9696                size = 256;
    9797
    98         rc = devmap_device_get_handle(argv[1], &handle, 0);
     98        rc = loc_service_get_id(argv[1], &service_id, 0);
    9999        if (rc != EOK) {
    100100                printf("%s: Error resolving device `%s'.\n", cmdname, argv[1]);
    … …  
    102102        }
    103103
    104         rc = block_init(EXCHANGE_SERIALIZE, handle, 2048);
     104        rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
    105105        if (rc != EOK)  {
    106106                printf("%s: Error initializing libblock.\n", cmdname);
    … …  
    108108        }
    109109
    110         rc = block_get_bsize(handle, &block_size);
     110        rc = block_get_bsize(service_id, &block_size);
    111111        if (rc != EOK) {
    112112                printf("%s: Error determining device block size.\n", cmdname);
    … …  
    117117        if (blk == NULL) {
    118118                printf("%s: Error allocating memory.\n", cmdname);
    119                 block_fini(handle);
     119                block_fini(service_id);
    120120                return CMD_FAILURE;
    121121        }
    … …  
    124124
    125125        while (size > 0) {
    126                 rc = block_read_direct(handle, ba, 1, blk);
     126                rc = block_read_direct(service_id, ba, 1, blk);
    127127                if (rc != EOK) {
    128128                        printf("%s: Error reading block %" PRIuOFF64 "\n", cmdname, ba);
    129129                        free(blk);
    130                         block_fini(handle);
     130                        block_fini(service_id);
    131131                        return CMD_FAILURE;
    132132                }
    … …  
    170170
    171171        free(blk);
    172         block_fini(handle);
     172        block_fini(service_id);
    173173
    174174        return CMD_SUCCESS;

  • uspace/app/blkdump/blkdump.c

    rd894fbd r903bac0a  
    4242#include <libblock.h>
    4343#include <mem.h>
    44 #include <devmap.h>
     44#include <loc.h>
    4545#include <byteorder.h>
    4646#include <sys/types.h>
    … …  
    5959        int rc;
    6060        char *dev_path;
    61         devmap_handle_t handle;
     61        service_id_t service_id;
    6262        size_t block_size;
    6363        char *endptr;
    … …  
    128128        dev_path = *argv;
    129129
    130         rc = devmap_device_get_handle(dev_path, &handle, 0);
     130        rc = loc_service_get_id(dev_path, &service_id, 0);
    131131        if (rc != EOK) {
    132132                printf(NAME ": Error resolving device `%s'.\n", dev_path);
    … …  
    134134        }
    135135
    136         rc = block_init(EXCHANGE_SERIALIZE, handle, 2048);
     136        rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
    137137        if (rc != EOK)  {
    138138                printf(NAME ": Error initializing libblock.\n");
    … …  
    140140        }
    141141
    142         rc = block_get_bsize(handle, &block_size);
     142        rc = block_get_bsize(service_id, &block_size);
    143143        if (rc != EOK) {
    144144                printf(NAME ": Error determining device block size.\n");
    … …  
    146146        }
    147147
    148         rc = block_get_nblocks(handle, &dev_nblocks);
     148        rc = block_get_nblocks(service_id, &dev_nblocks);
    149149        if (rc != EOK) {
    150150                printf(NAME ": Warning, failed to obtain block device size.\n");
    … …  
    156156        if (data == NULL) {
    157157                printf(NAME ": Error allocating data buffer of %" PRIuOFF64 " bytes", (aoff64_t) block_size);
    158                 block_fini(handle);
     158                block_fini(service_id);
    159159                return 3;
    160160        }
    … …  
    162162        limit = block_offset + block_count;
    163163        for (current = block_offset; current < limit; current++) {
    164                 rc = block_read_direct(handle, current, 1, data);
     164                rc = block_read_direct(service_id, current, 1, data);
    165165                if (rc != EOK) {
    166166                        printf(NAME ": Error reading block at %" PRIuOFF64 " \n", current);
    … …  
    186186        free(data);
    187187
    188         block_fini(handle);
     188        block_fini(service_id);
    189189
    190190        return 0;

  • uspace/app/bnchmark/bnchmark.c

    rd894fbd r903bac0a  
    4141#include <stdlib.h>
    4242#include <mem.h>
    43 #include <devmap.h>
     43#include <loc.h>
    4444#include <byteorder.h>
    4545#include <sys/types.h>

  • uspace/app/ext2info/ext2info.c

    rd894fbd r903bac0a  
    4242#include <libblock.h>
    4343#include <mem.h>
    44 #include <devmap.h>
     44#include <loc.h>
    4545#include <byteorder.h>
    4646#include <sys/types.h>
    … …  
    8181        char *endptr;
    8282        char *dev_path;
    83         devmap_handle_t handle;
     83        service_id_t service_id;
    8484        ext2_filesystem_t filesystem;
    8585        int arg_flags;
    … …  
    178178        dev_path = *argv;
    179179
    180         rc = devmap_device_get_handle(dev_path, &handle, 0);
     180        rc = loc_service_get_id(dev_path, &service_id, 0);
    181181        if (rc != EOK) {
    182182                printf(NAME ": Error resolving device `%s'.\n", dev_path);
    … …  
    184184        }
    185185
    186         rc = ext2_filesystem_init(&filesystem, handle);
     186        rc = ext2_filesystem_init(&filesystem, service_id);
    187187        if (rc != EOK)  {
    188188                printf(NAME ": Error initializing libext2.\n");

  • uspace/app/init/init.c

    rd894fbd r903bac0a  
    4646#include <macros.h>
    4747#include <str.h>
    48 #include <devmap.h>
     48#include <loc.h>
    4949#include <str_error.h>
    5050#include "init.h"
    … …  
    5353#define ROOT_MOUNT_POINT  "/"
    5454
    55 #define DEVFS_FS_TYPE      "devfs"
    56 #define DEVFS_MOUNT_POINT  "/dev"
     55#define LOCFS_FS_TYPE      "locfs"
     56#define LOCFS_MOUNT_POINT  "/loc"
    5757
    5858#define TMPFS_FS_TYPE      "tmpfs"
    … …  
    6666#define APP_GETTERM  "/app/getterm"
    6767
     68/** Print banner */
    6869static void info_print(void)
    6970{
    … …  
    7172}
    7273
     74/** Report mount operation success */
    7375static bool mount_report(const char *desc, const char *mntpt,
    7476    const char *fstype, const char *dev, int rc)
    … …  
    100102}
    101103
     104/** Mount root filesystem
     105 *
     106 * The operation blocks until the root filesystem
     107 * server is ready for mounting.
     108 *
     109 * @param[in] fstype Root filesystem type.
     110 *
     111 * @return True on success.
     112 * @return False on failure.
     113 *
     114 */
    102115static bool mount_root(const char *fstype)
    103116{
    … …  
    113126}
    114127
    115 static bool mount_devfs(void)
    116 {
    117         int rc = mount(DEVFS_FS_TYPE, DEVFS_MOUNT_POINT, "", "",
     128/** Mount locfs filesystem
     129 *
     130 * The operation blocks until the locfs filesystem
     131 * server is ready for mounting.
     132 *
     133 * @return True on success.
     134 * @return False on failure.
     135 *
     136 */
     137static bool mount_locfs(void)
     138{
     139        int rc = mount(LOCFS_FS_TYPE, LOCFS_MOUNT_POINT, "", "",
    118140            IPC_FLAG_BLOCKING);
    119         return mount_report("Device filesystem", DEVFS_MOUNT_POINT, DEVFS_FS_TYPE,
    120             NULL, rc);
     141        return mount_report("Location service filesystem", LOCFS_MOUNT_POINT,
     142            LOCFS_FS_TYPE, NULL, rc);
    121143}
    122144
    … …  
    157179        rc = task_wait(id, &texit, &retval);
    158180        if (rc != EOK) {
    159                 printf("%s: Error waiting for %s (%s(\n", NAME, fname,
     181                printf("%s: Error waiting for %s (%s)\n", NAME, fname,
    160182                    str_error(rc));
    161183                return;
    … …  
    174196}
    175197
    176 static void console(const char *dev)
    177 {
    178         printf("%s: Spawning %s %s\n", NAME, SRV_CONSOLE, dev);
    179        
    180         /* Wait for the input device to be ready */
    181         devmap_handle_t handle;
    182         int rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
    183         if (rc != EOK) {
    184                 printf("%s: Error waiting on %s (%s)\n", NAME, dev,
    185                     str_error(rc));
    186                 return;
    187         }
    188        
    189         rc = task_spawnl(NULL, SRV_CONSOLE, SRV_CONSOLE, dev, NULL);
     198static void console(const char *svc)
     199{
     200        printf("%s: Spawning %s %s\n", NAME, SRV_CONSOLE, svc);
     201       
     202        /* Wait for the input service to be ready */
     203        service_id_t service_id;
     204        int rc = loc_service_get_id(svc, &service_id, IPC_FLAG_BLOCKING);
     205        if (rc != EOK) {
     206                printf("%s: Error waiting on %s (%s)\n", NAME, svc,
     207                    str_error(rc));
     208                return;
     209        }
     210       
     211        rc = task_spawnl(NULL, SRV_CONSOLE, SRV_CONSOLE, svc, NULL);
    190212        if (rc != EOK) {
    191213                printf("%s: Error spawning %s %s (%s)\n", NAME, SRV_CONSOLE,
    192                     dev, str_error(rc));
    193         }
    194 }
    195 
    196 static void getterm(const char *dev, const char *app, bool wmsg)
    197 {
    198         char term[DEVMAP_NAME_MAXLEN];
     214                    svc, str_error(rc));
     215        }
     216}
     217
     218static void getterm(const char *svc, const char *app, bool wmsg)
     219{
     220        char term[LOC_NAME_MAXLEN];
    199221        int rc;
    200222       
    201         snprintf(term, DEVMAP_NAME_MAXLEN, "%s/%s", DEVFS_MOUNT_POINT, dev);
     223        snprintf(term, LOC_NAME_MAXLEN, "%s/%s", LOCFS_MOUNT_POINT, svc);
    202224       
    203225        printf("%s: Spawning %s %s %s\n", NAME, APP_GETTERM, term, app);
    204226       
    205         /* Wait for the terminal device to be ready */
    206         devmap_handle_t handle;
    207         rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
     227        /* Wait for the terminal service to be ready */
     228        service_id_t service_id;
     229        rc = loc_service_get_id(svc, &service_id, IPC_FLAG_BLOCKING);
    208230        if (rc != EOK) {
    209231                printf("%s: Error waiting on %s (%s)\n", NAME, term,
    … …  
    257279        }
    258280       
    259         spawn("/srv/devfs");
     281        spawn("/srv/locfs");
    260282        spawn("/srv/taskmon");
    261283       
    262         if (!mount_devfs()) {
     284        if (!mount_locfs()) {
    263285                printf("%s: Exiting\n", NAME);
    264286                return -2;

  • uspace/app/locinfo/locinfo.c

    rd894fbd r903bac0a  
    11/*
    2  * Copyright (c) 2011 Vojtech Horky
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup tester
    30  * @brief Test devman service.
     29/** @addtogroup locinfo
    3130 * @{
    3231 */
    33 /**
    34  * @file
     32/** @file locinfo.c Print information from location service.
    3533 */
    3634
    37 #include <inttypes.h>
    3835#include <errno.h>
    39 #include <str_error.h>
     36#include <loc.h>
     37#include <stdio.h>
     38#include <stdlib.h>
     39#include <str.h>
    4040#include <sys/types.h>
    41 #include <async.h>
    42 #include <devman.h>
    43 #include <str.h>
    44 #include <vfs/vfs.h>
    45 #include <sys/stat.h>
    46 #include <fcntl.h>
    47 #include "../tester.h"
     41#include <sys/typefmt.h>
    4842
    49 #define DEVICE_PATH_NORMAL "/virt/null/a"
    50 #define DEVICE_CLASS "virt-null"
    51 #define DEVICE_CLASS_NAME "1"
    52 #define DEVICE_PATH_CLASSES DEVICE_CLASS "/" DEVICE_CLASS_NAME
     43#define NAME "locinfo"
    5344
    54 const char *test_devman1(void)
     45int main(int argc, char *argv[])
    5546{
    56         devman_handle_t handle_primary;
    57         devman_handle_t handle_class;
    58        
     47        category_id_t *cat_ids;
     48        size_t cat_cnt;
     49        service_id_t *svc_ids;
     50        size_t svc_cnt;
     51
     52        size_t i, j;
     53        char *cat_name;
     54        char *svc_name;
    5955        int rc;
    60        
    61         TPRINTF("Asking for handle of `%s'...\n", DEVICE_PATH_NORMAL);
    62         rc = devman_device_get_handle(DEVICE_PATH_NORMAL, &handle_primary, 0);
     56
     57        rc = loc_get_categories(&cat_ids, &cat_cnt);
    6358        if (rc != EOK) {
    64                 TPRINTF(" ...failed: %s.\n", str_error(rc));
    65                 if (rc == ENOENT) {
    66                         TPRINTF("Have you compiled the test drivers?\n");
    67                 }
    68                 return "Failed getting device handle";
     59                printf(NAME ": Error getting list of categories.\n");
     60                return 1;
    6961        }
    7062
    71         TPRINTF("Asking for handle of `%s' by class..\n", DEVICE_PATH_CLASSES);
    72         rc = devman_device_get_handle_by_class(DEVICE_CLASS, DEVICE_CLASS_NAME,
    73             &handle_class, 0);
    74         if (rc != EOK) {
    75                 TPRINTF(" ...failed: %s.\n", str_error(rc));
    76                 return "Failed getting device class handle";
     63        for (i = 0; i < cat_cnt; i++) {
     64                rc = loc_category_get_name(cat_ids[i], &cat_name);
     65                if (rc != EOK)
     66                        cat_name = str_dup("<unknown>");
     67
     68                if (cat_name == NULL) {
     69                        printf(NAME ": Error allocating memory.\n");
     70                        return 1;
     71                }
     72
     73                printf("%s (%" PRIun "):\n", cat_name, cat_ids[i]);
     74
     75                rc = loc_category_get_svcs(cat_ids[i], &svc_ids, &svc_cnt);
     76                if (rc != EOK) {
     77                        printf(NAME ": Failed getting list of services in "
     78                            "category %s, skipping.\n", cat_name);
     79                        free(cat_name);
     80                        continue;
     81                }
     82
     83                for (j = 0; j < svc_cnt; j++) {
     84                        rc = loc_service_get_name(svc_ids[j], &svc_name);
     85                        if (rc != EOK) {
     86                                printf(NAME ": Unknown service name (SID %"
     87                                    PRIun ").\n", svc_ids[j]);
     88                                continue;
     89                        }
     90                        printf("\t%s (%" PRIun ")\n", svc_name, svc_ids[j]);
     91                }
     92
     93                free(svc_ids);
     94                free(cat_name);
    7795        }
    7896
    79         TPRINTF("Received handles %" PRIun " and %" PRIun ".\n",
    80             handle_primary, handle_class);
    81         if (handle_primary != handle_class) {
    82                 return "Retrieved different handles for the same device";
    83         }
    84 
    85         return NULL;
     97        free(cat_ids);
     98        return 0;
    8699}
    87100

  • uspace/app/lsusb/main.c

    rd894fbd r903bac0a  
    4343#include <getopt.h>
    4444#include <devman.h>
    45 #include <devmap.h>
     45#include <loc.h>
    4646#include <usb/dev/hub.h>
    4747#include <usb/hc.h>
    … …  
    5050
    5151#define MAX_USB_ADDRESS USB11_ADDRESS_MAX
    52 #define MAX_FAILED_ATTEMPTS 10
    5352#define MAX_PATH_LENGTH 1024
    5453
    55 static void print_found_hc(size_t class_index, const char *path)
     54static void print_found_hc(service_id_t sid, const char *path)
    5655{
    57         // printf(NAME ": host controller %zu is `%s'.\n", class_index, path);
    58         printf("Bus %02zu: %s\n", class_index, path);
     56        printf("Bus %" PRIun ": %s\n", sid, path);
    5957}
    6058static void print_found_dev(usb_address_t addr, const char *path)
    6159{
    62         // printf(NAME ":     device with address %d is `%s'.\n", addr, path);
    6360        printf("  Device %02d: %s\n", addr, path);
    6461}
    … …  
    9592int main(int argc, char *argv[])
    9693{
    97         size_t class_index = 0;
    98         size_t failed_attempts = 0;
     94        category_id_t usbhc_cat;
     95        service_id_t *svcs;
     96        size_t count;
     97        size_t i;
     98        int rc;
    9999
    100         while (failed_attempts < MAX_FAILED_ATTEMPTS) {
    101                 class_index++;
     100        rc = loc_category_get_id(USB_HC_CATEGORY, &usbhc_cat, 0);
     101        if (rc != EOK) {
     102                printf(NAME ": Error resolving category '%s'",
     103                    USB_HC_CATEGORY);
     104                return 1;
     105        }
     106
     107        rc = loc_category_get_svcs(usbhc_cat, &svcs, &count);
     108        if (rc != EOK) {
     109                printf(NAME ": Error getting list of host controllers.\n");
     110                return 1;
     111        }
     112
     113        for (i = 0; i < count; i++) {
    102114                devman_handle_t hc_handle = 0;
    103                 int rc = usb_ddf_get_hc_handle_by_class(class_index, &hc_handle);
     115                int rc = usb_ddf_get_hc_handle_by_sid(svcs[i], &hc_handle);
    104116                if (rc != EOK) {
    105                         failed_attempts++;
     117                        printf(NAME ": Error resolving handle of HC with SID %"
     118                            PRIun ", skipping.\n", svcs[i]);
    106119                        continue;
    107120                }
    … …  
    109122                rc = devman_get_device_path(hc_handle, path, MAX_PATH_LENGTH);
    110123                if (rc != EOK) {
     124                        printf(NAME ": Error resolving path of HC with SID %"
     125                            PRIun ", skipping.\n", svcs[i]);
    111126                        continue;
    112127                }
    113                 print_found_hc(class_index, path);
     128                print_found_hc(svcs[i], path);
    114129                print_hc_devices(hc_handle);
    115130        }
     131
     132        free(svcs);
    116133
    117134        return 0;

  • uspace/app/mkbd/main.c

    rd894fbd r903bac0a  
    4343#include <getopt.h>
    4444#include <devman.h>
    45 #include <devmap.h>
     45#include <loc.h>
    4646#include <usb/dev/hub.h>
    4747#include <usb/hid/iface.h>

  • uspace/app/mkfat/mkfat.c

    rd894fbd r903bac0a  
    4242#include <libblock.h>
    4343#include <mem.h>
    44 #include <devmap.h>
     44#include <loc.h>
    4545#include <byteorder.h>
    4646#include <sys/types.h>
    … …  
    8585    struct fat_params *par);
    8686static int fat_blocks_write(struct fat_params const *par,
    87     devmap_handle_t handle);
     87    service_id_t service_id);
    8888static void fat_bootsec_create(struct fat_params const *par, struct fat_bs *bs);
    8989
    … …  
    9595        int rc;
    9696        char *dev_path;
    97         devmap_handle_t handle;
     97        service_id_t service_id;
    9898        size_t block_size;
    9999        char *endptr;
    … …  
    138138        dev_path = *argv;
    139139
    140         rc = devmap_device_get_handle(dev_path, &handle, 0);
     140        rc = loc_service_get_id(dev_path, &service_id, 0);
    141141        if (rc != EOK) {
    142142                printf(NAME ": Error resolving device `%s'.\n", dev_path);
    … …  
    144144        }
    145145
    146         rc = block_init(EXCHANGE_SERIALIZE, handle, 2048);
     146        rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048);
    147147        if (rc != EOK)  {
    148148                printf(NAME ": Error initializing libblock.\n");
    … …  
    150150        }
    151151
    152         rc = block_get_bsize(handle, &block_size);
     152        rc = block_get_bsize(service_id, &block_size);
    153153        if (rc != EOK) {
    154154                printf(NAME ": Error determining device block size.\n");
    … …  
    156156        }
    157157
    158         rc = block_get_nblocks(handle, &dev_nblocks);
     158        rc = block_get_nblocks(service_id, &dev_nblocks);
    159159        if (rc != EOK) {
    160160                printf(NAME ": Warning, failed to obtain block device size.\n");
    … …  
    183183        }
    184184
    185         rc = fat_blocks_write(&par, handle);
     185        rc = fat_blocks_write(&par, service_id);
    186186        if (rc != EOK) {
    187187                printf(NAME ": Error writing device.\n");
    … …  
    189189        }
    190190
    191         block_fini(handle);
     191        block_fini(service_id);
    192192        printf("Success.\n");
    193193
    … …  
    234234
    235235/** Create file system with the given parameters. */
    236 static int fat_blocks_write(struct fat_params const *par, devmap_handle_t handle)
     236static int fat_blocks_write(struct fat_params const *par, service_id_t service_id)
    237237{
    238238        aoff64_t addr;
    … …  
    245245        fat_bootsec_create(par, &bs);
    246246
    247         rc = block_write_direct(handle, BS_BLOCK, 1, &bs);
     247        rc = block_write_direct(service_id, BS_BLOCK, 1, &bs);
    248248        if (rc != EOK)
    249249                return EIO;
    … …  
    257257        /* Reserved sectors */
    258258        for (i = 0; i < par->reserved_sectors - 1; ++i) {
    259                 rc = block_write_direct(handle, addr, 1, buffer);
     259                rc = block_write_direct(service_id, addr, 1, buffer);
    260260                if (rc != EOK)
    261261                        return EIO;
    … …  
    277277                        }
    278278
    279                         rc = block_write_direct(handle, addr, 1, buffer);
     279                        rc = block_write_direct(service_id, addr, 1, buffer);
    280280                        if (rc != EOK)
    281281                                return EIO;
    … …  
    291291        /* Root directory */
    292292        for (i = 0; i < par->rootdir_sectors; ++i) {
    293                 rc = block_write_direct(handle, addr, 1, buffer);
     293                rc = block_write_direct(service_id, addr, 1, buffer);
    294294                if (rc != EOK)
    295295                        return EIO;

  • uspace/app/tester/Makefile

    rd894fbd r903bac0a  
    5656        mm/malloc3.c \
    5757        mm/mapping1.c \
    58         devs/devman1.c \
    59         devs/devman2.c \
    6058        hw/misc/virtchar1.c \
    6159        hw/serial/serial1.c \

  • uspace/app/tester/hw/misc/virtchar1.c

    rd894fbd r903bac0a  
    4848#include "../../tester.h"
    4949
    50 #define DEVICE_PATH_NORMAL "/dev/devices/\\virt\\null\\a"
    51 #define DEVICE_PATH_CLASSES "/dev/class/virt-null\\1"
     50#define DEVICE_PATH_NORMAL "/loc/devices/\\virt\\null\\a"
    5251#define BUFFER_SIZE 64
    5352
    … …  
    105104        }
    106105
    107         res = test_virtchar1_internal(DEVICE_PATH_CLASSES);
    108         if (res != NULL) {
    109                 return res;
    110         }
    111 
    112106        return NULL;
    113107}

  • uspace/app/tester/tester.c

    rd894fbd r903bac0a  
    6868#include "hw/misc/virtchar1.def"
    6969#include "libext2/libext2_1.def"
    70 #include "devs/devman1.def"
    71 #include "devs/devman2.def"
    7270        {NULL, NULL, NULL, false}
    7371};

  • uspace/app/tester/vfs/vfs1.c

    rd894fbd r903bac0a  
    3535#include <fcntl.h>
    3636#include <dirent.h>
    37 #include <devmap.h>
     37#include <loc.h>
    3838#include <sys/types.h>
    3939#include <sys/stat.h>

  • uspace/app/testread/testread.c

    rd894fbd r903bac0a  
    5050#include <stdlib.h>
    5151#include <mem.h>
    52 #include <devmap.h>
     52#include <loc.h>
    5353#include <byteorder.h>
    5454#include <sys/types.h>

  • uspace/app/usbinfo/main.c

    rd894fbd r903bac0a  
    4242#include <getopt.h>
    4343#include <devman.h>
    44 #include <devmap.h>
     44#include <loc.h>
    4545#include <usb/hc.h>
    4646#include <usb/dev/pipes.h>
Note: See TracChangeset for help on using the changeset viewer.