Changeset ffa2c8ef in mainline for uspace/srv/bd


Ignore:
Timestamp:
2011-01-29T11:36:08Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
46b881c
Parents:
64d2b10
Message:

do not intermix low-level IPC methods with async framework methods

Location:
uspace/srv/bd
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/ata_bd/ata_bd.c

    r64d2b10 rffa2c8ef  
    5151#include <libarch/ddi.h>
    5252#include <ddi.h>
    53 #include <ipc/ipc.h>
    5453#include <ipc/bd.h>
    5554#include <async.h>
    … …  
    282281
    283282        if (disk_id < 0 || disk[disk_id].present == false) {
    284                 ipc_answer_0(iid, EINVAL);
     283                async_answer_0(iid, EINVAL);
    285284                return;
    286285        }
    287286
    288287        /* Answer the IPC_M_CONNECT_ME_TO call. */
    289         ipc_answer_0(iid, EOK);
     288        async_answer_0(iid, EOK);
    290289
    291290        if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    292                 ipc_answer_0(callid, EHANGUP);
     291                async_answer_0(callid, EHANGUP);
    293292                return;
    294293        }
    … …  
    296295        fs_va = as_get_mappable_page(comm_size);
    297296        if (fs_va == NULL) {
    298                 ipc_answer_0(callid, EHANGUP);
     297                async_answer_0(callid, EHANGUP);
    299298                return;
    300299        }
    … …  
    308307                case IPC_M_PHONE_HUNGUP:
    309308                        /* The other side has hung up. */
    310                         ipc_answer_0(callid, EOK);
     309                        async_answer_0(callid, EOK);
    311310                        return;
    312311                case BD_READ_BLOCKS:
    … …  
    331330                        break;
    332331                case BD_GET_BLOCK_SIZE:
    333                         ipc_answer_1(callid, EOK, block_size);
     332                        async_answer_1(callid, EOK, block_size);
    334333                        continue;
    335334                case BD_GET_NUM_BLOCKS:
    336                         ipc_answer_2(callid, EOK, LOWER32(disk[disk_id].blocks),
     335                        async_answer_2(callid, EOK, LOWER32(disk[disk_id].blocks),
    337336                            UPPER32(disk[disk_id].blocks));
    338337                        continue;
    … …  
    341340                        break;
    342341                }
    343                 ipc_answer_0(callid, retval);
     342                async_answer_0(callid, retval);
    344343        }
    345344}

  • uspace/srv/bd/file_bd/file_bd.c

    r64d2b10 rffa2c8ef  
    4141#include <stdio.h>
    4242#include <unistd.h>
    43 #include <ipc/ipc.h>
    4443#include <ipc/bd.h>
    4544#include <async.h>
    … …  
    184183
    185184        /* Answer the IPC_M_CONNECT_ME_TO call. */
    186         ipc_answer_0(iid, EOK);
     185        async_answer_0(iid, EOK);
    187186
    188187        if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    189                 ipc_answer_0(callid, EHANGUP);
     188                async_answer_0(callid, EHANGUP);
    190189                return;
    191190        }
    … …  
    193192        fs_va = as_get_mappable_page(comm_size);
    194193        if (fs_va == NULL) {
    195                 ipc_answer_0(callid, EHANGUP);
     194                async_answer_0(callid, EHANGUP);
    196195                return;
    197196        }
    … …  
    205204                case IPC_M_PHONE_HUNGUP:
    206205                        /* The other side has hung up. */
    207                         ipc_answer_0(callid, EOK);
     206                        async_answer_0(callid, EOK);
    208207                        return;
    209208                case BD_READ_BLOCKS:
    … …  
    228227                        break;
    229228                case BD_GET_BLOCK_SIZE:
    230                         ipc_answer_1(callid, EOK, block_size);
     229                        async_answer_1(callid, EOK, block_size);
    231230                        continue;
    232231                case BD_GET_NUM_BLOCKS:
    233                         ipc_answer_2(callid, EOK, LOWER32(num_blocks),
     232                        async_answer_2(callid, EOK, LOWER32(num_blocks),
    234233                            UPPER32(num_blocks));
    235234                        continue;
    … …  
    238237                        break;
    239238                }
    240                 ipc_answer_0(callid, retval);
     239                async_answer_0(callid, retval);
    241240        }
    242241}

  • uspace/srv/bd/gxe_bd/gxe_bd.c

    r64d2b10 rffa2c8ef  
    3939#include <libarch/ddi.h>
    4040#include <ddi.h>
    41 #include <ipc/ipc.h>
    4241#include <ipc/bd.h>
    4342#include <async.h>
    … …  
    177176
    178177        if (disk_id < 0) {
    179                 ipc_answer_0(iid, EINVAL);
     178                async_answer_0(iid, EINVAL);
    180179                return;
    181180        }
    182181
    183182        /* Answer the IPC_M_CONNECT_ME_TO call. */
    184         ipc_answer_0(iid, EOK);
     183        async_answer_0(iid, EOK);
    185184
    186185        if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    187                 ipc_answer_0(callid, EHANGUP);
     186                async_answer_0(callid, EHANGUP);
    188187                return;
    189188        }
    190189
    191190        if (comm_size < block_size) {
    192                 ipc_answer_0(callid, EHANGUP);
     191                async_answer_0(callid, EHANGUP);
    193192                return;
    194193        }
    … …  
    196195        fs_va = as_get_mappable_page(comm_size);
    197196        if (fs_va == NULL) {
    198                 ipc_answer_0(callid, EHANGUP);
     197                async_answer_0(callid, EHANGUP);
    199198                return;
    200199        }
    … …  
    208207                case IPC_M_PHONE_HUNGUP:
    209208                        /* The other side has hung up. */
    210                         ipc_answer_0(callid, EOK);
     209                        async_answer_0(callid, EOK);
    211210                        return;
    212211                case BD_READ_BLOCKS:
    … …  
    231230                        break;
    232231                case BD_GET_BLOCK_SIZE:
    233                         ipc_answer_1(callid, EOK, block_size);
     232                        async_answer_1(callid, EOK, block_size);
    234233                        continue;
    235234                case BD_GET_NUM_BLOCKS:
    … …  
    240239                        break;
    241240                }
    242                 ipc_answer_0(callid, retval);
     241                async_answer_0(callid, retval);
    243242        }
    244243}

  • uspace/srv/bd/part/guid_part/guid_part.c

    r64d2b10 rffa2c8ef  
    4747#include <stdlib.h>
    4848#include <unistd.h>
    49 #include <ipc/ipc.h>
    5049#include <ipc/bd.h>
    5150#include <async.h>
    … …  
    335334
    336335        if (part == NULL) {
    337                 ipc_answer_0(iid, EINVAL);
     336                async_answer_0(iid, EINVAL);
    338337                return;
    339338        }
    … …  
    342341
    343342        /* Answer the IPC_M_CONNECT_ME_TO call. */
    344         ipc_answer_0(iid, EOK);
     343        async_answer_0(iid, EOK);
    345344
    346345        if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    347                 ipc_answer_0(callid, EHANGUP);
     346                async_answer_0(callid, EHANGUP);
    348347                return;
    349348        }
    … …  
    351350        fs_va = as_get_mappable_page(comm_size);
    352351        if (fs_va == NULL) {
    353                 ipc_answer_0(callid, EHANGUP);
     352                async_answer_0(callid, EHANGUP);
    354353                return;
    355354        }
    … …  
    363362                case IPC_M_PHONE_HUNGUP:
    364363                        /* The other side has hung up. */
    365                         ipc_answer_0(callid, EOK);
     364                        async_answer_0(callid, EOK);
    366365                        return;
    367366                case BD_READ_BLOCKS:
    … …  
    386385                        break;
    387386                case BD_GET_BLOCK_SIZE:
    388                         ipc_answer_1(callid, EOK, block_size);
     387                        async_answer_1(callid, EOK, block_size);
    389388                        continue;
    390389                case BD_GET_NUM_BLOCKS:
    391                         ipc_answer_2(callid, EOK, LOWER32(part->length),
     390                        async_answer_2(callid, EOK, LOWER32(part->length),
    392391                            UPPER32(part->length));
    393392                        continue;
    … …  
    396395                        break;
    397396                }
    398                 ipc_answer_0(callid, retval);
     397                async_answer_0(callid, retval);
    399398        }
    400399}

  • uspace/srv/bd/part/mbr_part/mbr_part.c

    r64d2b10 rffa2c8ef  
    5757#include <stdlib.h>
    5858#include <unistd.h>
    59 #include <ipc/ipc.h>
    6059#include <ipc/bd.h>
    6160#include <async.h>
    … …  
    413412
    414413        if (part == NULL) {
    415                 ipc_answer_0(iid, EINVAL);
     414                async_answer_0(iid, EINVAL);
    416415                return;
    417416        }
    … …  
    420419
    421420        /* Answer the IPC_M_CONNECT_ME_TO call. */
    422         ipc_answer_0(iid, EOK);
     421        async_answer_0(iid, EOK);
    423422
    424423        if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    425                 ipc_answer_0(callid, EHANGUP);
     424                async_answer_0(callid, EHANGUP);
    426425                return;
    427426        }
    … …  
    429428        fs_va = as_get_mappable_page(comm_size);
    430429        if (fs_va == NULL) {
    431                 ipc_answer_0(callid, EHANGUP);
     430                async_answer_0(callid, EHANGUP);
    432431                return;
    433432        }
    … …  
    441440                case IPC_M_PHONE_HUNGUP:
    442441                        /* The other side has hung up. */
    443                         ipc_answer_0(callid, EOK);
     442                        async_answer_0(callid, EOK);
    444443                        return;
    445444                case BD_READ_BLOCKS:
    … …  
    464463                        break;
    465464                case BD_GET_BLOCK_SIZE:
    466                         ipc_answer_1(callid, EOK, block_size);
     465                        async_answer_1(callid, EOK, block_size);
    467466                        continue;
    468467                case BD_GET_NUM_BLOCKS:
    469                         ipc_answer_2(callid, EOK, LOWER32(part->length),
     468                        async_answer_2(callid, EOK, LOWER32(part->length),
    470469                            UPPER32(part->length));
    471470                        continue;
    … …  
    474473                        break;
    475474                }
    476                 ipc_answer_0(callid, retval);
     475                async_answer_0(callid, retval);
    477476        }
    478477}

  • uspace/srv/bd/rd/rd.c

    r64d2b10 rffa2c8ef  
    3939 */
    4040
    41 #include <ipc/ipc.h>
    4241#include <ipc/services.h>
    4342#include <ipc/ns.h>
    … …  
    9897         * Answer the first IPC_M_CONNECT_ME_TO call.
    9998         */
    100         ipc_answer_0(iid, EOK);
     99        async_answer_0(iid, EOK);
    101100       
    102101        /*
    … …  
    109108                        (void) async_share_out_finalize(callid, fs_va);
    110109                } else {
    111                         ipc_answer_0(callid, EHANGUP);
     110                        async_answer_0(callid, EHANGUP);
    112111                        return;
    113112                }
    … …  
    118117                 * Close the connection.
    119118                 */
    120                 ipc_answer_0(callid, EHANGUP);
     119                async_answer_0(callid, EHANGUP);
    121120                return;
    122121        }
    … …  
    130129                         * Answer the message and exit the fibril.
    131130                         */
    132                         ipc_answer_0(callid, EOK);
     131                        async_answer_0(callid, EOK);
    133132                        return;
    134133                case BD_READ_BLOCKS:
    … …  
    153152                        break;
    154153                case BD_GET_BLOCK_SIZE:
    155                         ipc_answer_1(callid, EOK, block_size);
     154                        async_answer_1(callid, EOK, block_size);
    156155                        continue;
    157156                case BD_GET_NUM_BLOCKS:
    158                         ipc_answer_2(callid, EOK, LOWER32(rd_size / block_size),
     157                        async_answer_2(callid, EOK, LOWER32(rd_size / block_size),
    159158                            UPPER32(rd_size / block_size));
    160159                        continue;
    … …  
    169168                        break;
    170169                }
    171                 ipc_answer_0(callid, retval);
     170                async_answer_0(callid, retval);
    172171        }
    173172}
Note: See TracChangeset for help on using the changeset viewer.