Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/async.c

    raddbce4 rb7fd2a0  
    205205        ipc_call_t *dataptr;
    206206       
    207         sysarg_t retval;
     207        errno_t retval;
    208208} amsg_t;
    209209
    … …  
    332332                msg->destroyed = false;
    333333                msg->dataptr = NULL;
    334                 msg->retval = (sysarg_t) EINVAL;
     334                msg->retval = EINVAL;
    335335                awaiter_initialize(&msg->wdata);
    336336        }
    … …  
    511511static FIBRIL_CONDVAR_INITIALIZE(avail_phone_cv);
    512512
    513 int async_create_port(iface_t iface, async_port_handler_t handler,
     513errno_t async_create_port(iface_t iface, async_port_handler_t handler,
    514514    void *data, port_id_t *port_id)
    515515{
    … …  
    698698 *
    699699 */
    700 static int connection_fibril(void *arg)
     700static errno_t connection_fibril(void *arg)
    701701{
    702702        assert(arg);
    … …  
    763763       
    764764        free(fibril_connection);
    765         return 0;
     765        return EOK;
    766766}
    767767
    … …  
    844844 * @param port_id ID of the newly created port.
    845845 *
    846  * @return Zero on success or a negative error code.
    847  *
    848  */
    849 int async_create_callback_port(async_exch_t *exch, iface_t iface, sysarg_t arg1,
     846 * @return Zero on success or an error code.
     847 *
     848 */
     849errno_t async_create_callback_port(async_exch_t *exch, iface_t iface, sysarg_t arg1,
    850850    sysarg_t arg2, async_port_handler_t handler, void *data, port_id_t *port_id)
    851851{
    … …  
    860860            &answer);
    861861       
    862         sysarg_t ret;
     862        errno_t ret;
    863863        async_wait_for(req, &ret);
    864864        if (ret != EOK)
    865                 return (int) ret;
     865                return (errno_t) ret;
    866866       
    867867        sysarg_t phone_hash = IPC_GET_ARG5(answer);
    … …  
    10511051 * @param ucode   Top-half pseudocode handler.
    10521052 *
    1053  * @return IRQ capability handle on success.
    1054  * @return Negative error code.
    1055  *
    1056  */
    1057 int async_irq_subscribe(int inr, async_notification_handler_t handler,
    1058     void *data, const irq_code_t *ucode)
     1053 * @param[out] handle  IRQ capability handle on success.
     1054 *
     1055 * @return An error code.
     1056 *
     1057 */
     1058errno_t async_irq_subscribe(int inr, async_notification_handler_t handler,
     1059    void *data, const irq_code_t *ucode, cap_handle_t *handle)
    10591060{
    10601061        notification_t *notification =
    … …  
    10761077        futex_up(&async_futex);
    10771078       
    1078         return ipc_irq_subscribe(inr, imethod, ucode);
     1079        cap_handle_t cap;
     1080        errno_t rc = ipc_irq_subscribe(inr, imethod, ucode, &cap);
     1081        if (rc == EOK && handle != NULL) {
     1082                *handle = cap;
     1083        }
     1084        return rc;
    10791085}
    10801086
    … …  
    10831089 * @param cap     IRQ capability handle.
    10841090 *
    1085  * @return Zero on success or a negative error code.
    1086  *
    1087  */
    1088 int async_irq_unsubscribe(int cap)
     1091 * @return Zero on success or an error code.
     1092 *
     1093 */
     1094errno_t async_irq_unsubscribe(int cap)
    10891095{
    10901096        // TODO: Remove entry from hash table
    … …  
    11001106 * @param data    Notification handler client data.
    11011107 *
    1102  * @return Zero on success or a negative error code.
    1103  *
    1104  */
    1105 int async_event_subscribe(event_type_t evno,
     1108 * @return Zero on success or an error code.
     1109 *
     1110 */
     1111errno_t async_event_subscribe(event_type_t evno,
    11061112    async_notification_handler_t handler, void *data)
    11071113{
    … …  
    11331139 * @param data    Notification handler client data.
    11341140 *
    1135  * @return Zero on success or a negative error code.
    1136  *
    1137  */
    1138 int async_event_task_subscribe(event_task_type_t evno,
     1141 * @return Zero on success or an error code.
     1142 *
     1143 */
     1144errno_t async_event_task_subscribe(event_task_type_t evno,
    11391145    async_notification_handler_t handler, void *data)
    11401146{
    … …  
    11671173 *
    11681174 */
    1169 int async_event_unmask(event_type_t evno)
     1175errno_t async_event_unmask(event_type_t evno)
    11701176{
    11711177        return ipc_event_unmask(evno);
    … …  
    11791185 *
    11801186 */
    1181 int async_event_task_unmask(event_task_type_t evno)
     1187errno_t async_event_task_unmask(event_task_type_t evno)
    11821188{
    11831189        return ipc_event_task_unmask(evno);
    … …  
    14311437 *
    14321438 */
    1433 static int async_manager_worker(void)
     1439static errno_t async_manager_worker(void)
    14341440{
    14351441        while (true) {
    … …  
    14831489               
    14841490                ipc_call_t call;
    1485                 cap_handle_t chandle = ipc_wait_cycle(&call, timeout, flags);
     1491                errno_t rc = ipc_wait_cycle(&call, timeout, flags);
    14861492               
    14871493                atomic_dec(&threads_in_ipc_wait);
    14881494               
    1489                 assert(chandle >= 0);
    1490 
    1491                 if (chandle == CAP_NIL) {
    1492                         if (call.flags == 0) {
    1493                                 /* This neither a notification nor an answer. */
     1495                assert(rc == EOK);
     1496
     1497                if (call.cap_handle == CAP_NIL) {
     1498                        if ((call.flags &
     1499                            (IPC_CALL_NOTIF | IPC_CALL_ANSWERED)) == 0) {
     1500                                /* Neither a notification nor an answer. */
    14941501                                handle_expired_timeouts();
    14951502                                continue;
    … …  
    15001507                        continue;
    15011508
    1502                 handle_call(chandle, &call);
     1509                handle_call(call.cap_handle, &call);
    15031510        }
    15041511
    … …  
    15141521 *
    15151522 */
    1516 static int async_manager_fibril(void *arg)
     1523static errno_t async_manager_fibril(void *arg)
    15171524{
    15181525        futex_up(&async_futex);
    … …  
    15901597 *
    15911598 */
    1592 void reply_received(void *arg, int retval, ipc_call_t *data)
     1599void reply_received(void *arg, errno_t retval, ipc_call_t *data)
    15931600{
    15941601        assert(arg);
    … …  
    17021709 *
    17031710 */
    1704 void async_wait_for(aid_t amsgid, sysarg_t *retval)
     1711void async_wait_for(aid_t amsgid, errno_t *retval)
    17051712{
    17061713        assert(amsgid);
    … …  
    17481755 *
    17491756 */
    1750 int async_wait_timeout(aid_t amsgid, sysarg_t *retval, suseconds_t timeout)
     1757errno_t async_wait_timeout(aid_t amsgid, errno_t *retval, suseconds_t timeout)
    17511758{
    17521759        assert(amsgid);
    … …  
    19081915 * @param r5      If non-NULL, storage for the 5th reply argument.
    19091916 *
    1910  * @return Return code of the reply or a negative error code.
    1911  *
    1912  */
    1913 sysarg_t async_req_fast(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     1917 * @return Return code of the reply or an error code.
     1918 *
     1919 */
     1920errno_t async_req_fast(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
    19141921    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
    19151922    sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    … …  
    19221929            &result);
    19231930       
    1924         sysarg_t rc;
     1931        errno_t rc;
    19251932        async_wait_for(aid, &rc);
    19261933       
    … …  
    19601967 * @param r5      If non-NULL, storage for the 5th reply argument.
    19611968 *
    1962  * @return Return code of the reply or a negative error code.
    1963  *
    1964  */
    1965 sysarg_t async_req_slow(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     1969 * @return Return code of the reply or an error code.
     1970 *
     1971 */
     1972errno_t async_req_slow(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
    19661973    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
    19671974    sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
    … …  
    19741981            &result);
    19751982       
    1976         sysarg_t rc;
     1983        errno_t rc;
    19771984        async_wait_for(aid, &rc);
    19781985       
    … …  
    20382045}
    20392046
    2040 sysarg_t async_answer_0(cap_handle_t chandle, sysarg_t retval)
     2047errno_t async_answer_0(cap_handle_t chandle, errno_t retval)
    20412048{
    20422049        return ipc_answer_0(chandle, retval);
    20432050}
    20442051
    2045 sysarg_t async_answer_1(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1)
     2052errno_t async_answer_1(cap_handle_t chandle, errno_t retval, sysarg_t arg1)
    20462053{
    20472054        return ipc_answer_1(chandle, retval, arg1);
    20482055}
    20492056
    2050 sysarg_t async_answer_2(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1,
     2057errno_t async_answer_2(cap_handle_t chandle, errno_t retval, sysarg_t arg1,
    20512058    sysarg_t arg2)
    20522059{
    … …  
    20542061}
    20552062
    2056 sysarg_t async_answer_3(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1,
     2063errno_t async_answer_3(cap_handle_t chandle, errno_t retval, sysarg_t arg1,
    20572064    sysarg_t arg2, sysarg_t arg3)
    20582065{
    … …  
    20602067}
    20612068
    2062 sysarg_t async_answer_4(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1,
     2069errno_t async_answer_4(cap_handle_t chandle, errno_t retval, sysarg_t arg1,
    20632070    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
    20642071{
    … …  
    20662073}
    20672074
    2068 sysarg_t async_answer_5(cap_handle_t chandle, sysarg_t retval, sysarg_t arg1,
     2075errno_t async_answer_5(cap_handle_t chandle, errno_t retval, sysarg_t arg1,
    20692076    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
    20702077{
    … …  
    20722079}
    20732080
    2074 int async_forward_fast(cap_handle_t chandle, async_exch_t *exch,
     2081errno_t async_forward_fast(cap_handle_t chandle, async_exch_t *exch,
    20752082    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
    20762083{
    … …  
    20812088}
    20822089
    2083 int async_forward_slow(cap_handle_t chandle, async_exch_t *exch,
     2090errno_t async_forward_slow(cap_handle_t chandle, async_exch_t *exch,
    20842091    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
    20852092    sysarg_t arg4, sysarg_t arg5, unsigned int mode)
    … …  
    21012108 * @param arg3            User defined argument.
    21022109 *
    2103  * @return Zero on success or a negative error code.
    2104  *
    2105  */
    2106 int async_connect_to_me(async_exch_t *exch, sysarg_t arg1, sysarg_t arg2,
     2110 * @return Zero on success or an error code.
     2111 *
     2112 */
     2113errno_t async_connect_to_me(async_exch_t *exch, sysarg_t arg1, sysarg_t arg2,
    21072114    sysarg_t arg3)
    21082115{
    … …  
    21142121            &answer);
    21152122       
    2116         sysarg_t rc;
     2123        errno_t rc;
    21172124        async_wait_for(req, &rc);
    21182125        if (rc != EOK)
    2119                 return (int) rc;
     2126                return (errno_t) rc;
    21202127       
    21212128        return EOK;
    21222129}
    21232130
    2124 static int async_connect_me_to_internal(int phone, sysarg_t arg1, sysarg_t arg2,
    2125     sysarg_t arg3, sysarg_t arg4)
     2131static errno_t async_connect_me_to_internal(int phone, sysarg_t arg1, sysarg_t arg2,
     2132    sysarg_t arg3, sysarg_t arg4, int *out_phone)
    21262133{
    21272134        ipc_call_t result;
     2135       
     2136        // XXX: Workaround for GCC's inability to infer association between
     2137        // rc == EOK and *out_phone being assigned.
     2138        *out_phone = -1;
    21282139       
    21292140        amsg_t *msg = amsg_create();
    … …  
    21372148            msg, reply_received);
    21382149       
    2139         sysarg_t rc;
     2150        errno_t rc;
    21402151        async_wait_for((aid_t) msg, &rc);
    21412152       
    … …  
    21432154                return rc;
    21442155       
    2145         return (int) IPC_GET_ARG5(result);
     2156        *out_phone = (int) IPC_GET_ARG5(result);
     2157        return EOK;
    21462158}
    21472159
    … …  
    21732185        }
    21742186       
    2175         int phone = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
    2176             0);
    2177         if (phone < 0) {
    2178                 errno = phone;
     2187        int phone;
     2188        errno_t rc = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
     2189            0, &phone);
     2190        if (rc != EOK) {
     2191                errno = rc;
    21792192                free(sess);
    21802193                return NULL;
    … …  
    22252238        }
    22262239       
    2227         int phone = async_connect_me_to_internal(exch->phone, iface, arg2,
    2228             arg3, 0);
    2229         if (phone < 0) {
    2230                 errno = phone;
     2240        int phone;
     2241        errno_t rc = async_connect_me_to_internal(exch->phone, iface, arg2,
     2242            arg3, 0, &phone);
     2243        if (rc != EOK) {
     2244                errno = rc;
    22312245                free(sess);
    22322246                return NULL;
    … …  
    22952309        }
    22962310       
    2297         int phone = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
    2298             IPC_FLAG_BLOCKING);
    2299        
    2300         if (phone < 0) {
    2301                 errno = phone;
     2311        int phone;
     2312        errno_t rc = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
     2313            IPC_FLAG_BLOCKING, &phone);
     2314       
     2315        if (rc != EOK) {
     2316                errno = rc;
    23022317                free(sess);
    23032318                return NULL;
    … …  
    23482363        }
    23492364       
    2350         int phone = async_connect_me_to_internal(exch->phone, iface, arg2,
    2351             arg3, IPC_FLAG_BLOCKING);
    2352         if (phone < 0) {
    2353                 errno = phone;
     2365        int phone;
     2366        errno_t rc = async_connect_me_to_internal(exch->phone, iface, arg2,
     2367            arg3, IPC_FLAG_BLOCKING, &phone);
     2368        if (rc != EOK) {
     2369                errno = rc;
    23542370                free(sess);
    23552371                return NULL;
    … …  
    23832399        }
    23842400       
    2385         int phone = ipc_connect_kbox(id);
    2386         if (phone < 0) {
    2387                 errno = phone;
     2401        cap_handle_t phone;
     2402        errno_t rc = ipc_connect_kbox(id, &phone);
     2403        if (rc != EOK) {
     2404                errno = rc;
    23882405                free(sess);
    23892406                return NULL;
    … …  
    24072424}
    24082425
    2409 static int async_hangup_internal(int phone)
     2426static errno_t async_hangup_internal(int phone)
    24102427{
    24112428        return ipc_hangup(phone);
    … …  
    24162433 * @param sess Session to hung up.
    24172434 *
    2418  * @return Zero on success or a negative error code.
    2419  *
    2420  */
    2421 int async_hangup(async_sess_t *sess)
     2435 * @return Zero on success or an error code.
     2436 *
     2437 */
     2438errno_t async_hangup(async_sess_t *sess)
    24222439{
    24232440        async_exch_t *exch;
    … …  
    24302447        fibril_mutex_lock(&async_sess_mutex);
    24312448       
    2432         int rc = async_hangup_internal(sess->phone);
     2449        errno_t rc = async_hangup_internal(sess->phone);
    24332450       
    24342451        while (!list_empty(&sess->exch_list)) {
    … …  
    25022519                } else if (mgmt == EXCHANGE_PARALLEL) {
    25032520                        int phone;
     2521                        errno_t rc;
    25042522                       
    25052523                retry:
    … …  
    25072525                         * Make a one-time attempt to connect a new data phone.
    25082526                         */
    2509                         phone = async_connect_me_to_internal(sess->phone, sess->arg1,
    2510                             sess->arg2, sess->arg3, 0);
    2511                         if (phone >= 0) {
     2527                        rc = async_connect_me_to_internal(sess->phone, sess->arg1,
     2528                            sess->arg2, sess->arg3, 0, &phone);
     2529                        if (rc == EOK) {
    25122530                                exch = (async_exch_t *) malloc(sizeof(async_exch_t));
    25132531                                if (exch != NULL) {
    … …  
    25952613 *              base address. Cannot be NULL.
    25962614 *
    2597  * @return Zero on success or a negative error code from errno.h.
    2598  *
    2599  */
    2600 int async_share_in_start(async_exch_t *exch, size_t size, sysarg_t arg,
     2615 * @return Zero on success or an error code from errno.h.
     2616 *
     2617 */
     2618errno_t async_share_in_start(async_exch_t *exch, size_t size, sysarg_t arg,
    26012619    unsigned int *flags, void **dst)
    26022620{
    … …  
    26062624        sysarg_t _flags = 0;
    26072625        sysarg_t _dst = (sysarg_t) -1;
    2608         int res = async_req_2_4(exch, IPC_M_SHARE_IN, (sysarg_t) size,
     2626        errno_t res = async_req_2_4(exch, IPC_M_SHARE_IN, (sysarg_t) size,
    26092627            arg, NULL, &_flags, NULL, &_dst);
    26102628       
    … …  
    26582676 *
    26592677 */
    2660 int async_share_in_finalize(cap_handle_t chandle, void *src, unsigned int flags)
     2678errno_t async_share_in_finalize(cap_handle_t chandle, void *src, unsigned int flags)
    26612679{
    26622680        return ipc_answer_3(chandle, EOK, (sysarg_t) src, (sysarg_t) flags,
    … …  
    26702688 * @param flags Flags to be used for sharing. Bits can be only cleared.
    26712689 *
    2672  * @return Zero on success or a negative error code from errno.h.
    2673  *
    2674  */
    2675 int async_share_out_start(async_exch_t *exch, void *src, unsigned int flags)
     2690 * @return Zero on success or an error code from errno.h.
     2691 *
     2692 */
     2693errno_t async_share_out_start(async_exch_t *exch, void *src, unsigned int flags)
    26762694{
    26772695        if (exch == NULL)
    … …  
    27282746 *
    27292747 */
    2730 int async_share_out_finalize(cap_handle_t chandle, void **dst)
     2748errno_t async_share_out_finalize(cap_handle_t chandle, void **dst)
    27312749{
    27322750        return ipc_answer_2(chandle, EOK, (sysarg_t) __entry, (sysarg_t) dst);
    … …  
    27562774 * @param size Size of the destination buffer.
    27572775 *
    2758  * @return Zero on success or a negative error code from errno.h.
    2759  *
    2760  */
    2761 int async_data_read_start(async_exch_t *exch, void *dst, size_t size)
     2776 * @return Zero on success or an error code from errno.h.
     2777 *
     2778 */
     2779errno_t async_data_read_start(async_exch_t *exch, void *dst, size_t size)
    27622780{
    27632781        if (exch == NULL)
    … …  
    28332851 *
    28342852 */
    2835 int async_data_read_finalize(cap_handle_t chandle, const void *src, size_t size)
     2853errno_t async_data_read_finalize(cap_handle_t chandle, const void *src, size_t size)
    28362854{
    28372855        return ipc_answer_2(chandle, EOK, (sysarg_t) src, (sysarg_t) size);
    … …  
    28412859 *
    28422860 */
    2843 int async_data_read_forward_fast(async_exch_t *exch, sysarg_t imethod,
     2861errno_t async_data_read_forward_fast(async_exch_t *exch, sysarg_t imethod,
    28442862    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4,
    28452863    ipc_call_t *dataptr)
    … …  
    28612879        }
    28622880       
    2863         int retval = ipc_forward_fast(chandle, exch->phone, 0, 0, 0,
     2881        errno_t retval = ipc_forward_fast(chandle, exch->phone, 0, 0, 0,
    28642882            IPC_FF_ROUTE_FROM_ME);
    28652883        if (retval != EOK) {
    … …  
    28692887        }
    28702888       
    2871         sysarg_t rc;
     2889        errno_t rc;
    28722890        async_wait_for(msg, &rc);
    28732891       
    2874         return (int) rc;
     2892        return (errno_t) rc;
    28752893}
    28762894
    … …  
    28812899 * @param size Size of the source buffer.
    28822900 *
    2883  * @return Zero on success or a negative error code from errno.h.
    2884  *
    2885  */
    2886 int async_data_write_start(async_exch_t *exch, const void *src, size_t size)
     2901 * @return Zero on success or an error code from errno.h.
     2902 *
     2903 */
     2904errno_t async_data_write_start(async_exch_t *exch, const void *src, size_t size)
    28872905{
    28882906        if (exch == NULL)
    … …  
    29582976 *
    29592977 */
    2960 int async_data_write_finalize(cap_handle_t chandle, void *dst, size_t size)
     2978errno_t async_data_write_finalize(cap_handle_t chandle, void *dst, size_t size)
    29612979{
    29622980        return ipc_answer_2(chandle, EOK, (sysarg_t) dst, (sysarg_t) size);
    … …  
    29843002 *
    29853003 */
    2986 int async_data_write_accept(void **data, const bool nullterm,
     3004errno_t async_data_write_accept(void **data, const bool nullterm,
    29873005    const size_t min_size, const size_t max_size, const size_t granularity,
    29883006    size_t *received)
    … …  
    30243042        }
    30253043       
    3026         int rc = async_data_write_finalize(chandle, arg_data, size);
     3044        errno_t rc = async_data_write_finalize(chandle, arg_data, size);
    30273045        if (rc != EOK) {
    30283046                free(arg_data);
    … …  
    30473065 *
    30483066 */
    3049 void async_data_write_void(sysarg_t retval)
     3067void async_data_write_void(errno_t retval)
    30503068{
    30513069        cap_handle_t chandle;
    … …  
    30573075 *
    30583076 */
    3059 int async_data_write_forward_fast(async_exch_t *exch, sysarg_t imethod,
     3077errno_t async_data_write_forward_fast(async_exch_t *exch, sysarg_t imethod,
    30603078    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4,
    30613079    ipc_call_t *dataptr)
    … …  
    30773095        }
    30783096       
    3079         int retval = ipc_forward_fast(chandle, exch->phone, 0, 0, 0,
     3097        errno_t retval = ipc_forward_fast(chandle, exch->phone, 0, 0, 0,
    30803098            IPC_FF_ROUTE_FROM_ME);
    30813099        if (retval != EOK) {
    … …  
    30853103        }
    30863104       
    3087         sysarg_t rc;
     3105        errno_t rc;
    30883106        async_wait_for(msg, &rc);
    30893107       
    3090         return (int) rc;
     3108        return (errno_t) rc;
    30913109}
    30923110
    … …  
    31823200}
    31833201
    3184 int async_state_change_start(async_exch_t *exch, sysarg_t arg1, sysarg_t arg2,
     3202errno_t async_state_change_start(async_exch_t *exch, sysarg_t arg1, sysarg_t arg2,
    31853203    sysarg_t arg3, async_exch_t *other_exch)
    31863204{
    … …  
    32103228}
    32113229
    3212 int async_state_change_finalize(cap_handle_t chandle, async_exch_t *other_exch)
     3230errno_t async_state_change_finalize(cap_handle_t chandle, async_exch_t *other_exch)
    32133231{
    32143232        return ipc_answer_1(chandle, EOK, other_exch->phone);
Note: See TracChangeset for help on using the changeset viewer.