Changes in / [fb7e5a9a:7a46bfe] in mainline


Ignore:
Files:
6 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    rfb7e5a9a r7a46bfe  
    103103        $(USPACE_PATH)/srv/fs/fat/fat \
    104104        $(USPACE_PATH)/srv/fs/mfs/mfs \
    105         $(USPACE_PATH)/srv/fs/cdfs/cdfs \
    106105        $(USPACE_PATH)/srv/fs/exfat/exfat \
    107106        $(USPACE_PATH)/srv/fs/ext2fs/ext2fs \

  • tools/toolchain.sh

    rfb7e5a9a r7a46bfe  
    5353EOF
    5454
    55 BINUTILS_VERSION="2.21.1"
    56 BINUTILS_RELEASE="a"
     55BINUTILS_VERSION="2.21"
    5756GCC_VERSION="4.6.1"
    58 GDB_VERSION="7.3.1"
     57GDB_VERSION="7.2"
    5958
    6059BASEDIR="`pwd`"
    61 BINUTILS="binutils-${BINUTILS_VERSION}${BINUTILS_RELEASE}.tar.bz2"
     60BINUTILS="binutils-${BINUTILS_VERSION}.tar.bz2"
    6261GCC_CORE="gcc-core-${GCC_VERSION}.tar.bz2"
    6362GCC_OBJC="gcc-objc-${GCC_VERSION}.tar.bz2"
    … …  
    274273        GDB_SOURCE="ftp://ftp.gnu.org/gnu/gdb/"
    275274       
    276         download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "bde820eac53fa3a8d8696667418557ad"
     275        download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "c84c5acc9d266f1a7044b51c85a823f5"
    277276        download_fetch "${GCC_SOURCE}" "${GCC_CORE}" "0c0e7e35d2215e19de9c97efba507553"
    278277        download_fetch "${GCC_SOURCE}" "${GCC_OBJC}" "cbf0d4b701827922cf37ba6a4ace0079"
    279278        download_fetch "${GCC_SOURCE}" "${GCC_CPP}" "0d75ca7ca35b1e7f252223f9d23a6ad1"
    280         download_fetch "${GDB_SOURCE}" "${GDB}" "b89a5fac359c618dda97b88645ceab47"
     279        download_fetch "${GDB_SOURCE}" "${GDB}" "64260e6c56979ee750a01055f16091a5"
    281280}
    282281

  • uspace/Makefile

    rfb7e5a9a r7a46bfe  
    8282        srv/fs/exfat \
    8383        srv/fs/fat \
    84         srv/fs/cdfs \
    8584        srv/fs/tmpfs \
    8685        srv/fs/mfs \

  • uspace/app/mkmfs/mkmfs.c

    rfb7e5a9a r7a46bfe  
    114114        int rc, c, opt_ind;
    115115        char *device_name;
    116         size_t devblock_size;
     116        aoff64_t devblock_size;
    117117
    118118        struct mfs_sb_info sb;

  • uspace/drv/test/test1/test1.c

    rfb7e5a9a r7a46bfe  
    4242static int test1_add_device(ddf_dev_t *dev);
    4343static int test1_dev_remove(ddf_dev_t *dev);
    44 static int test1_dev_gone(ddf_dev_t *dev);
    4544static int test1_fun_online(ddf_fun_t *fun);
    4645static int test1_fun_offline(ddf_fun_t *fun);
    … …  
    4948        .add_device = &test1_add_device,
    5049        .dev_remove = &test1_dev_remove,
    51         .dev_gone = &test1_dev_gone,
    5250        .fun_online = &test1_fun_online,
    5351        .fun_offline = &test1_fun_offline
    … …  
    215213}
    216214
    217 static int fun_unbind(ddf_fun_t *fun, const char *name)
    218 {
    219         int rc;
    220 
    221         ddf_msg(LVL_DEBUG, "fun_unbind(%p, '%s')", fun, name);
    222         rc = ddf_fun_unbind(fun);
    223         if (rc != EOK) {
    224                 ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", name);
    225                 return rc;
    226         }
    227 
    228         ddf_fun_destroy(fun);
    229         return EOK;
    230 }
    231 
    232215static int test1_dev_remove(ddf_dev_t *dev)
    233216{
    … …  
    258241}
    259242
    260 static int test1_dev_gone(ddf_dev_t *dev)
    261 {
    262         test1_t *test1 = (test1_t *)dev->driver_data;
    263         int rc;
    264 
    265         ddf_msg(LVL_DEBUG, "test1_dev_remove(%p)", dev);
    266 
    267         if (test1->fun_a != NULL) {
    268                 rc = fun_unbind(test1->fun_a, "a");
    269                 if (rc != EOK)
    270                         return rc;
    271         }
    272 
    273         if (test1->clone != NULL) {
    274                 rc = fun_unbind(test1->clone, "clone");
    275                 if (rc != EOK)
    276                         return rc;
    277         }
    278 
    279         if (test1->child != NULL) {
    280                 rc = fun_unbind(test1->child, "child");
    281                 if (rc != EOK)
    282                         return rc;
    283         }
    284 
    285         return EOK;
    286 }
    287 
    288243static int test1_fun_online(ddf_fun_t *fun)
    289244{

  • uspace/drv/test/test2/test2.c

    rfb7e5a9a r7a46bfe  
    4242static int test2_add_device(ddf_dev_t *dev);
    4343static int test2_dev_remove(ddf_dev_t *dev);
    44 static int test2_dev_gone(ddf_dev_t *dev);
    4544static int test2_fun_online(ddf_fun_t *fun);
    4645static int test2_fun_offline(ddf_fun_t *fun);
    … …  
    4948        .add_device = &test2_add_device,
    5049        .dev_remove = &test2_dev_remove,
    51         .dev_gone = &test2_dev_gone,
    5250        .fun_online = &test2_fun_online,
    5351        .fun_offline = &test2_fun_offline
    … …  
    113111}
    114112
    115 /** Simulate plugging and surprise unplugging.
     113/** Add child devices after some sleep.
    116114 *
    117115 * @param arg Parent device structure (ddf_dev_t *).
    118116 * @return Always EOK.
    119117 */
    120 static int plug_unplug(void *arg)
     118static int postponed_birth(void *arg)
    121119{
    122120        test2_t *test2 = (test2_t *) arg;
    … …  
    146144        test2->fun_a = fun_a;
    147145
    148         async_usleep(10000000);
    149 
    150         ddf_msg(LVL_NOTE, "Unbinding function test1.");
    151         ddf_fun_unbind(test2->test1);
    152         async_usleep(1000000);
    153         ddf_msg(LVL_NOTE, "Unbinding function child.");
    154         ddf_fun_unbind(test2->child);
    155 
    156146        return EOK;
    157147}
    … …  
    168158        }
    169159
    170         rc = ddf_fun_unbind(fun);
    171         if (rc != EOK) {
    172                 ddf_msg(LVL_ERROR, "Failed unbinding function '%s'.", name);
    173                 return rc;
    174         }
    175 
    176         ddf_fun_destroy(fun);
    177         return EOK;
    178 }
    179 
    180 static int fun_unbind(ddf_fun_t *fun, const char *name)
    181 {
    182         int rc;
    183 
    184         ddf_msg(LVL_DEBUG, "fun_unbind(%p, '%s')", fun, name);
    185160        rc = ddf_fun_unbind(fun);
    186161        if (rc != EOK) {
    … …  
    209184
    210185        if (str_cmp(dev->name, "child") != 0) {
    211                 fid_t postpone = fibril_create(plug_unplug, test2);
     186                fid_t postpone = fibril_create(postponed_birth, test2);
    212187                if (postpone == 0) {
    213188                        ddf_msg(LVL_ERROR, "fibril_create() failed.");
    … …  
    257232}
    258233
    259 static int test2_dev_gone(ddf_dev_t *dev)
    260 {
    261         test2_t *test2 = (test2_t *)dev->driver_data;
    262         int rc;
    263 
    264         ddf_msg(LVL_DEBUG, "test2_dev_gone(%p)", dev);
    265 
    266         if (test2->fun_a != NULL) {
    267                 rc = fun_unbind(test2->fun_a, "a");
    268                 if (rc != EOK)
    269                         return rc;
    270         }
    271 
    272         if (test2->fun_err != NULL) {
    273                 rc = fun_unbind(test2->fun_err, "ERROR");
    274                 if (rc != EOK)
    275                         return rc;
    276         }
    277 
    278         if (test2->child != NULL) {
    279                 rc = fun_unbind(test2->child, "child");
    280                 if (rc != EOK)
    281                         return rc;
    282         }
    283 
    284         if (test2->test1 != NULL) {
    285                 rc = fun_unbind(test2->test1, "test1");
    286                 if (rc != EOK)
    287                         return rc;
    288         }
    289 
    290         return EOK;
    291 }
    292 
    293234
    294235static int test2_fun_online(ddf_fun_t *fun)
    … …  
    307248{
    308249        printf(NAME ": HelenOS test2 virtual device driver\n");
    309         ddf_log_init(NAME, LVL_NOTE);
     250        ddf_log_init(NAME, LVL_ERROR);
    310251        return ddf_driver_main(&test2_driver);
    311252}

  • uspace/lib/block/libblock.c

    rfb7e5a9a r7a46bfe  
    9393static int get_block_size(async_sess_t *, size_t *);
    9494static int get_num_blocks(async_sess_t *, aoff64_t *);
     95static int read_toc(async_sess_t *, uint8_t);
    9596static aoff64_t ba_ltop(devcon_t *, aoff64_t);
    9697
    … …  
    895896 * @param service_id Service ID of the block device.
    896897 * @param session    Starting session.
    897  *
    898  * @return Allocated TOC structure.
    899  * @return NULL on failure.
    900  *
    901  */
    902 toc_block_t *block_get_toc(service_id_t service_id, uint8_t session)
     898 * @param data       Buffer to read TOC into.
     899 *
     900 * @return EOK on success.
     901 * @return Error code on failure.
     902 *
     903 */
     904int block_get_toc(service_id_t service_id, uint8_t session, void *data)
    903905{
    904906        devcon_t *devcon = devcon_search(service_id);
    905907        assert(devcon);
    906908       
    907         toc_block_t *toc = NULL;
    908        
    909909        fibril_mutex_lock(&devcon->comm_area_lock);
    910910       
    911         async_exch_t *exch = async_exchange_begin(devcon->sess);
    912         int rc = async_req_1_0(exch, BD_READ_TOC, session);
    913         async_exchange_end(exch);
    914        
    915         if (rc == EOK) {
    916                 toc = (toc_block_t *) malloc(sizeof(toc_block_t));
    917                 if (toc != NULL) {
    918                         memset(toc, 0, sizeof(toc_block_t));
    919                         memcpy(toc, devcon->comm_area,
    920                             min(devcon->pblock_size, sizeof(toc_block_t)));
    921                 }
    922         }
    923        
     911        int rc = read_toc(devcon->sess, session);
     912        if (rc == EOK)
     913                memcpy(data, devcon->comm_area, devcon->pblock_size);
    924914       
    925915        fibril_mutex_unlock(&devcon->comm_area_lock);
    926916       
    927         return toc;
     917        return rc;
    928918}
    929919
    … …  
    10181008}
    10191009
     1010/** Get TOC from block device. */
     1011static int read_toc(async_sess_t *sess, uint8_t session)
     1012{
     1013        async_exch_t *exch = async_exchange_begin(sess);
     1014        int rc = async_req_1_0(exch, BD_READ_TOC, session);
     1015        async_exchange_end(exch);
     1016
     1017        return rc;
     1018}
     1019
    10201020/** Convert logical block address to physical block address. */
    10211021static aoff64_t ba_ltop(devcon_t *devcon, aoff64_t lba)

  • uspace/lib/block/libblock.h

    rfb7e5a9a r7a46bfe  
    9797};
    9898
    99 typedef struct {
    100         uint16_t size;
    101         uint8_t first_session;
    102         uint8_t last_session;
    103        
    104         uint8_t res0;
    105         uint8_t adr_ctrl;
    106         uint8_t first_track;
    107         uint8_t res1;
    108        
    109         uint32_t first_lba;
    110 } __attribute__((packed)) toc_block_t;
    111 
    11299extern int block_init(exch_mgmt_t, service_id_t, size_t);
    113100extern void block_fini(service_id_t);
    … …  
    127114extern int block_get_bsize(service_id_t, size_t *);
    128115extern int block_get_nblocks(service_id_t, aoff64_t *);
    129 extern toc_block_t *block_get_toc(service_id_t, uint8_t);
     116extern int block_get_toc(service_id_t, uint8_t, void *);
    130117extern int block_read_direct(service_id_t, aoff64_t, size_t, void *);
    131118extern int block_read_bytes_direct(service_id_t, aoff64_t, size_t, void *);
    … …  
    136123/** @}
    137124 */
     125

  • uspace/lib/c/generic/str.c

    rfb7e5a9a r7a46bfe  
    12911291}
    12921292
    1293 /** Convert string to uint8_t.
    1294  *
    1295  * @param nptr   Pointer to string.
    1296  * @param endptr If not NULL, pointer to the first invalid character
    1297  *               is stored here.
    1298  * @param base   Zero or number between 2 and 36 inclusive.
    1299  * @param strict Do not allow any trailing characters.
    1300  * @param result Result of the conversion.
    1301  *
    1302  * @return EOK if conversion was successful.
    1303  *
    1304  */
    1305 int str_uint8_t(const char *nptr, char **endptr, unsigned int base,
    1306     bool strict, uint8_t *result)
    1307 {
    1308         assert(result != NULL);
    1309        
    1310         bool neg;
    1311         char *lendptr;
    1312         uint64_t res;
    1313         int ret = str_uint(nptr, &lendptr, base, &neg, &res);
    1314        
    1315         if (endptr != NULL)
    1316                 *endptr = (char *) lendptr;
    1317        
    1318         if (ret != EOK)
    1319                 return ret;
    1320        
    1321         /* Do not allow negative values */
    1322         if (neg)
    1323                 return EINVAL;
    1324        
    1325         /* Check whether we are at the end of
    1326            the string in strict mode */
    1327         if ((strict) && (*lendptr != 0))
    1328                 return EINVAL;
    1329        
    1330         /* Check for overflow */
    1331         uint8_t _res = (uint8_t) res;
    1332         if (_res != res)
    1333                 return EOVERFLOW;
    1334        
    1335         *result = _res;
    1336        
    1337         return EOK;
    1338 }
    1339 
    1340 /** Convert string to uint16_t.
    1341  *
    1342  * @param nptr   Pointer to string.
    1343  * @param endptr If not NULL, pointer to the first invalid character
    1344  *               is stored here.
    1345  * @param base   Zero or number between 2 and 36 inclusive.
    1346  * @param strict Do not allow any trailing characters.
    1347  * @param result Result of the conversion.
    1348  *
    1349  * @return EOK if conversion was successful.
    1350  *
    1351  */
    1352 int str_uint16_t(const char *nptr, char **endptr, unsigned int base,
    1353     bool strict, uint16_t *result)
    1354 {
    1355         assert(result != NULL);
    1356        
    1357         bool neg;
    1358         char *lendptr;
    1359         uint64_t res;
    1360         int ret = str_uint(nptr, &lendptr, base, &neg, &res);
    1361        
    1362         if (endptr != NULL)
    1363                 *endptr = (char *) lendptr;
    1364        
    1365         if (ret != EOK)
    1366                 return ret;
    1367        
    1368         /* Do not allow negative values */
    1369         if (neg)
    1370                 return EINVAL;
    1371        
    1372         /* Check whether we are at the end of
    1373            the string in strict mode */
    1374         if ((strict) && (*lendptr != 0))
    1375                 return EINVAL;
    1376        
    1377         /* Check for overflow */
    1378         uint16_t _res = (uint16_t) res;
    1379         if (_res != res)
    1380                 return EOVERFLOW;
    1381        
    1382         *result = _res;
    1383        
    1384         return EOK;
    1385 }
    1386 
    1387 /** Convert string to uint32_t.
    1388  *
    1389  * @param nptr   Pointer to string.
    1390  * @param endptr If not NULL, pointer to the first invalid character
    1391  *               is stored here.
    1392  * @param base   Zero or number between 2 and 36 inclusive.
    1393  * @param strict Do not allow any trailing characters.
    1394  * @param result Result of the conversion.
    1395  *
    1396  * @return EOK if conversion was successful.
    1397  *
    1398  */
    1399 int str_uint32_t(const char *nptr, char **endptr, unsigned int base,
    1400     bool strict, uint32_t *result)
    1401 {
    1402         assert(result != NULL);
    1403        
    1404         bool neg;
    1405         char *lendptr;
    1406         uint64_t res;
    1407         int ret = str_uint(nptr, &lendptr, base, &neg, &res);
    1408        
    1409         if (endptr != NULL)
    1410                 *endptr = (char *) lendptr;
    1411        
    1412         if (ret != EOK)
    1413                 return ret;
    1414        
    1415         /* Do not allow negative values */
    1416         if (neg)
    1417                 return EINVAL;
    1418        
    1419         /* Check whether we are at the end of
    1420            the string in strict mode */
    1421         if ((strict) && (*lendptr != 0))
    1422                 return EINVAL;
    1423        
    1424         /* Check for overflow */
    1425         uint32_t _res = (uint32_t) res;
    1426         if (_res != res)
    1427                 return EOVERFLOW;
    1428        
    1429         *result = _res;
    1430        
    1431         return EOK;
    1432 }
    1433 
    14341293/** Convert string to uint64_t.
    14351294 *

  • uspace/lib/c/include/ipc/devman.h

    rfb7e5a9a r7a46bfe  
    147147        DRIVER_DEV_ADD = IPC_FIRST_USER_METHOD,
    148148        DRIVER_DEV_REMOVE,
    149         DRIVER_DEV_GONE,
    150149        DRIVER_FUN_ONLINE,
    151150        DRIVER_FUN_OFFLINE,
     151
    152152} devman_to_driver_t;
    153153

  • uspace/lib/c/include/str.h

    rfb7e5a9a r7a46bfe  
    9797extern char *str_ndup(const char *, size_t max_size);
    9898
    99 extern int str_uint8_t(const char *, char **, unsigned int, bool, uint8_t *);
    100 extern int str_uint16_t(const char *, char **, unsigned int, bool, uint16_t *);
    101 extern int str_uint32_t(const char *, char **, unsigned int, bool, uint32_t *);
    10299extern int str_uint64(const char *, char **, unsigned int, bool, uint64_t *);
    103100extern int str_size_t(const char *, char **, unsigned int, bool, size_t *);

  • uspace/lib/drv/generic/driver.c

    rfb7e5a9a r7a46bfe  
    333333}
    334334
    335 static void driver_dev_gone(ipc_callid_t iid, ipc_call_t *icall)
    336 {
    337         devman_handle_t devh;
    338         ddf_dev_t *dev;
    339         int rc;
    340        
    341         devh = IPC_GET_ARG1(*icall);
    342        
    343         fibril_mutex_lock(&devices_mutex);
    344         dev = driver_get_device(devh);
    345         if (dev != NULL)
    346                 dev_add_ref(dev);
    347         fibril_mutex_unlock(&devices_mutex);
    348        
    349         if (dev == NULL) {
    350                 async_answer_0(iid, ENOENT);
    351                 return;
    352         }
    353        
    354         if (driver->driver_ops->dev_gone != NULL)
    355                 rc = driver->driver_ops->dev_gone(dev);
    356         else
    357                 rc = ENOTSUP;
    358        
    359         if (rc == EOK)
    360                 dev_del_ref(dev);
    361        
    362         async_answer_0(iid, (sysarg_t) rc);
    363 }
    364 
    365335static void driver_fun_online(ipc_callid_t iid, ipc_call_t *icall)
    366336{
    … …  
    453423                case DRIVER_DEV_REMOVE:
    454424                        driver_dev_remove(callid, &call);
    455                         break;
    456                 case DRIVER_DEV_GONE:
    457                         driver_dev_gone(callid, &call);
    458425                        break;
    459426                case DRIVER_FUN_ONLINE:

  • uspace/lib/drv/include/ddf/driver.h

    rfb7e5a9a r7a46bfe  
    139139        /** Ask driver to remove a device */
    140140        int (*dev_remove)(ddf_dev_t *);
    141         /** Inform driver a device disappeared */
    142         int (*dev_gone)(ddf_dev_t *);
    143141        /** Ask driver to online a specific function */
    144142        int (*fun_online)(ddf_fun_t *);

  • uspace/lib/fs/libfs.c

    rfb7e5a9a r7a46bfe  
    837837        stat.is_directory = ops->is_directory(fn);
    838838        stat.size = ops->size_get(fn);
    839         stat.service = ops->service_get(fn);
     839        stat.service = ops->device_get(fn);
    840840       
    841841        ops->node_put(fn);

  • uspace/lib/fs/libfs.h

    rfb7e5a9a r7a46bfe  
    9292        bool (* is_directory)(fs_node_t *);
    9393        bool (* is_file)(fs_node_t *);
    94         service_id_t (* service_get)(fs_node_t *);
     94        service_id_t (* device_get)(fs_node_t *);
    9595} libfs_ops_t;
    9696

  • uspace/srv/devman/devman.c

    rfb7e5a9a r7a46bfe  
    878878       
    879879        return retval;
    880 }
    881 
    882 int driver_dev_gone(dev_tree_t *tree, dev_node_t *dev)
    883 {
    884         async_exch_t *exch;
    885         sysarg_t retval;
    886         driver_t *drv;
    887         devman_handle_t handle;
    888        
    889         assert(dev != NULL);
    890        
    891         log_msg(LVL_DEBUG, "driver_dev_gone(%p)", dev);
    892        
    893         fibril_rwlock_read_lock(&tree->rwlock);
    894         drv = dev->drv;
    895         handle = dev->handle;
    896         fibril_rwlock_read_unlock(&tree->rwlock);
    897        
    898         exch = async_exchange_begin(drv->sess);
    899         retval = async_req_1_0(exch, DRIVER_DEV_GONE, handle);
    900         async_exchange_end(exch);
    901        
    902         return retval;
     880
    903881}
    904882

  • uspace/srv/devman/devman.h

    rfb7e5a9a r7a46bfe  
    263263extern bool start_driver(driver_t *);
    264264extern int driver_dev_remove(dev_tree_t *, dev_node_t *);
    265 extern int driver_dev_gone(dev_tree_t *, dev_node_t *);
    266265extern int driver_fun_online(dev_tree_t *, fun_node_t *);
    267266extern int driver_fun_offline(dev_tree_t *, fun_node_t *);

  • uspace/srv/devman/main.c

    rfb7e5a9a r7a46bfe  
    316316                if (fun->child != NULL) {
    317317                        dev_node_t *dev = fun->child;
    318                         device_state_t dev_state;
    319318                       
    320319                        dev_add_ref(dev);
    321                         dev_state = dev->state;
     320                        fibril_rwlock_write_unlock(&device_tree.rwlock);
    322321                       
    323                         fibril_rwlock_write_unlock(&device_tree.rwlock);
    324 
    325322                        /* If device is owned by driver, ask driver to give it up. */
    326                         if (dev_state == DEVICE_USABLE) {
     323                        if (dev->state == DEVICE_USABLE) {
    327324                                rc = driver_dev_remove(&device_tree, dev);
    328325                                if (rc != EOK) {
    … …  
    336333                        if (!list_empty(&dev->functions)) {
    337334                                fibril_rwlock_read_unlock(&device_tree.rwlock);
    338                                 dev_del_ref(dev);
    339335                                return EIO;
    340336                        }
    341                        
    342337                        driver_t *driver = dev->drv;
    343338                        fibril_rwlock_read_unlock(&device_tree.rwlock);
    … …  
    512507        fun_node_t *fun;
    513508        int rc;
    514        
    515         log_msg(LVL_DEBUG, "devman_drv_fun_online()");
    516        
     509
     510        printf("devman_drv_fun_online()\n");
    517511        fun = find_fun_node(&device_tree, IPC_GET_ARG1(*icall));
    518512        if (fun == NULL) {
    … …  
    532526        rc = online_function(fun);
    533527        if (rc != EOK) {
     528                printf("devman_drv_fun_online() online_fun->ERROR\n");
    534529                fun_del_ref(fun);
    535530                async_answer_0(iid, (sysarg_t) rc);
    … …  
    538533       
    539534        fun_del_ref(fun);
     535        printf("devman_drv_fun_online() online_fun->OK\n");
    540536       
    541537        async_answer_0(iid, (sysarg_t) EOK);
    … …  
    584580        int rc;
    585581       
     582       
    586583        fun_node_t *fun = find_fun_node(&device_tree, fun_handle);
    587584        if (fun == NULL) {
    … …  
    602599       
    603600        if (fun->ftype == fun_inner) {
    604                 /* This is a surprise removal. Handle possible descendants */
     601                /* Handle possible descendants */
     602                /* TODO - This is a surprise removal */
    605603                if (fun->child != NULL) {
    606                         dev_node_t *dev = fun->child;
    607                         device_state_t dev_state;
    608                         int gone_rc;
    609                        
    610                         dev_add_ref(dev);
    611                         dev_state = dev->state;
    612                        
    613                         fibril_rwlock_write_unlock(&device_tree.rwlock);
    614                        
    615                         /* If device is owned by driver, inform driver it is gone. */
    616                         if (dev_state == DEVICE_USABLE)
    617                                 gone_rc = driver_dev_gone(&device_tree, dev);
    618                         else
    619                                 gone_rc = EOK;
    620                        
    621                         fibril_rwlock_read_lock(&device_tree.rwlock);
    622                        
    623                         /* Verify that driver succeeded and removed all functions */
    624                         if (gone_rc != EOK || !list_empty(&dev->functions)) {
    625                                 log_msg(LVL_ERROR, "Driver did not remove "
    626                                     "functions for device that is gone. "
    627                                     "Device node is now defunct.");
    628                                
    629                                 /*
    630                                  * Not much we can do but mark the device
    631                                  * node as having invalid state. This
    632                                  * is a driver bug.
    633                                  */
    634                                 dev->state = DEVICE_INVALID;
    635                                 fibril_rwlock_read_unlock(&device_tree.rwlock);
    636                                 dev_del_ref(dev);
    637                                 return;
    638                         }
    639                        
    640                         driver_t *driver = dev->drv;
    641                         fibril_rwlock_read_unlock(&device_tree.rwlock);
    642                        
    643                         if (driver)
    644                                 detach_driver(&device_tree, dev);
    645                        
    646                         fibril_rwlock_write_lock(&device_tree.rwlock);
    647                         remove_dev_node(&device_tree, dev);
    648                        
    649                         /* Delete ref created when node was inserted */
    650                         dev_del_ref(dev);
    651                         /* Delete ref created by dev_add_ref(dev) above */
    652                         dev_del_ref(dev);
     604                        log_msg(LVL_WARN, "devman_remove_function(): not handling "
     605                            "descendants\n");
    653606                }
    654607        } else {

  • uspace/srv/fs/exfat/exfat_ops.c

    rfb7e5a9a r7a46bfe  
    8787static bool exfat_is_directory(fs_node_t *);
    8888static bool exfat_is_file(fs_node_t *node);
    89 static service_id_t exfat_service_get(fs_node_t *node);
     89static service_id_t exfat_device_get(fs_node_t *node);
    9090
    9191/*
    … …  
    898898}
    899899
    900 service_id_t exfat_service_get(fs_node_t *node)
     900service_id_t exfat_device_get(fs_node_t *node)
    901901{
    902902        return 0;
    … …  
    921921        .is_directory = exfat_is_directory,
    922922        .is_file = exfat_is_file,
    923         .service_get = exfat_service_get
     923        .device_get = exfat_device_get
    924924};
    925925

  • uspace/srv/fs/ext2fs/ext2fs_ops.c

    rfb7e5a9a r7a46bfe  
    112112static bool ext2fs_is_directory(fs_node_t *);
    113113static bool ext2fs_is_file(fs_node_t *node);
    114 static service_id_t ext2fs_service_get(fs_node_t *node);
     114static service_id_t ext2fs_device_get(fs_node_t *node);
    115115
    116116/*
    … …  
    557557}
    558558
    559 service_id_t ext2fs_service_get(fs_node_t *fn)
     559service_id_t ext2fs_device_get(fs_node_t *fn)
    560560{
    561561        EXT2FS_DBG("");
    … …  
    581581        .is_directory = ext2fs_is_directory,
    582582        .is_file = ext2fs_is_file,
    583         .service_get = ext2fs_service_get
     583        .device_get = ext2fs_device_get
    584584};
    585585

  • uspace/srv/fs/fat/fat_ops.c

    rfb7e5a9a r7a46bfe  
    9090static bool fat_is_directory(fs_node_t *);
    9191static bool fat_is_file(fs_node_t *node);
    92 static service_id_t fat_service_get(fs_node_t *node);
     92static service_id_t fat_device_get(fs_node_t *node);
    9393
    9494/*
    … …  
    838838}
    839839
    840 service_id_t fat_service_get(fs_node_t *node)
     840service_id_t fat_device_get(fs_node_t *node)
    841841{
    842842        return 0;
    … …  
    860860        .is_directory = fat_is_directory,
    861861        .is_file = fat_is_file,
    862         .service_get = fat_service_get
     862        .device_get = fat_device_get
    863863};
    864864

  • uspace/srv/fs/locfs/locfs_ops.c

    rfb7e5a9a r7a46bfe  
    418418}
    419419
    420 static service_id_t locfs_service_get(fs_node_t *fn)
     420static service_id_t locfs_device_get(fs_node_t *fn)
    421421{
    422422        locfs_node_t *node = (locfs_node_t *) fn->data;
    … …  
    445445        .is_directory = locfs_is_directory,
    446446        .is_file = locfs_is_file,
    447         .service_get = locfs_service_get
     447        .device_get = locfs_device_get
    448448};
    449449

  • uspace/srv/fs/mfs/mfs_ops.c

    rfb7e5a9a r7a46bfe  
    5555static int mfs_has_children(bool *has_children, fs_node_t *fsnode);
    5656static int mfs_root_get(fs_node_t **rfn, service_id_t service_id);
    57 static service_id_t mfs_service_get(fs_node_t *fsnode);
     57static service_id_t mfs_device_get(fs_node_t *fsnode);
    5858static aoff64_t mfs_size_get(fs_node_t *node);
    5959static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component);
    … …  
    8181        .size_get = mfs_size_get,
    8282        .root_get = mfs_root_get,
    83         .service_get = mfs_service_get,
     83        .device_get = mfs_device_get,
    8484        .is_directory = mfs_is_directory,
    8585        .is_file = mfs_is_file,
    … …  
    325325}
    326326
    327 service_id_t mfs_service_get(fs_node_t *fsnode)
     327service_id_t mfs_device_get(fs_node_t *fsnode)
    328328{
    329329        struct mfs_node *node = fsnode->data;

  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    rfb7e5a9a r7a46bfe  
    114114}
    115115
    116 static service_id_t tmpfs_service_get(fs_node_t *fn)
     116static service_id_t tmpfs_device_get(fs_node_t *fn)
    117117{
    118118        return 0;
    … …  
    136136        .is_directory = tmpfs_is_directory,
    137137        .is_file = tmpfs_is_file,
    138         .service_get = tmpfs_service_get
     138        .device_get = tmpfs_device_get
    139139};
    140140

  • uspace/srv/loc/loc.c

    rfb7e5a9a r7a46bfe  
    12771277        categ_dir_add_cat(&cdir, cat);
    12781278
    1279         cat = category_new("test3");
    1280         categ_dir_add_cat(&cdir, cat);
    1281 
    12821279        cat = category_new("usbhc");
    12831280        categ_dir_add_cat(&cdir, cat);
    12841281
    1285         cat = category_new("virt-null");
    1286         categ_dir_add_cat(&cdir, cat);
    1287 
    12881282        cat = category_new("virtual");
    12891283        categ_dir_add_cat(&cdir, cat);
    1290 
    12911284
    12921285        return true;
Note: See TracChangeset for help on using the changeset viewer.