Lines Matching refs:service
168 vchiq_set_service_state(VCHIQ_SERVICE_T *service, int newstate)
171 service->state->id, service->localport,
172 srvstate_names[service->srvstate],
174 service->srvstate = newstate;
180 VCHIQ_SERVICE_T *service;
183 service = handle_to_service(handle);
184 if (service && (service->srvstate != VCHIQ_SRVSTATE_FREE) &&
185 (service->handle == handle)) {
186 BUG_ON(service->ref_count == 0);
187 service->ref_count++;
189 service = NULL;
192 if (!service)
194 "Invalid service handle 0x%x", handle);
196 return service;
202 VCHIQ_SERVICE_T *service = NULL;
205 service = state->services[localport];
206 if (service && (service->srvstate != VCHIQ_SRVSTATE_FREE)) {
207 BUG_ON(service->ref_count == 0);
208 service->ref_count++;
210 service = NULL;
214 if (!service)
218 return service;
224 VCHIQ_SERVICE_T *service;
227 service = handle_to_service(handle);
228 if (service && (service->srvstate != VCHIQ_SRVSTATE_FREE) &&
229 (service->handle == handle) &&
230 (service->instance == instance)) {
231 BUG_ON(service->ref_count == 0);
232 service->ref_count++;
234 service = NULL;
237 if (!service)
239 "Invalid service handle 0x%x", handle);
241 return service;
247 VCHIQ_SERVICE_T *service;
250 service = handle_to_service(handle);
251 if (service &&
252 ((service->srvstate == VCHIQ_SRVSTATE_FREE) ||
253 (service->srvstate == VCHIQ_SRVSTATE_CLOSED)) &&
254 (service->handle == handle) &&
255 (service->instance == instance)) {
256 BUG_ON(service->ref_count == 0);
257 service->ref_count++;
259 service = NULL;
262 if (!service)
264 "Invalid service handle 0x%x", handle);
266 return service;
273 VCHIQ_SERVICE_T *service = NULL;
281 service = srv;
282 BUG_ON(service->ref_count == 0);
283 service->ref_count++;
291 return service;
295 lock_service(VCHIQ_SERVICE_T *service)
298 BUG_ON(!service || (service->ref_count == 0));
299 if (service)
300 service->ref_count++;
305 unlock_service(VCHIQ_SERVICE_T *service)
307 VCHIQ_STATE_T *state = service->state;
309 BUG_ON(!service || (service->ref_count == 0));
310 if (service && service->ref_count) {
311 service->ref_count--;
312 if (!service->ref_count) {
313 BUG_ON(service->srvstate != VCHIQ_SRVSTATE_FREE);
314 state->services[service->localport] = NULL;
316 _sema_destroy(&service->remove_event);
317 _sema_destroy(&service->bulk_remove_event);
318 lmutex_destroy(&service->bulk_mutex);
320 service = NULL;
324 if (service && service->userdata_term)
325 service->userdata_term(service->base.userdata);
327 kfree(service);
333 VCHIQ_SERVICE_T *service = find_service_by_handle(handle);
336 id = service ? service->client_id : 0;
337 if (service)
338 unlock_service(service);
346 VCHIQ_SERVICE_T *service = handle_to_service(handle);
348 return service ? service->base.userdata : NULL;
354 VCHIQ_SERVICE_T *service = handle_to_service(handle);
356 return service ? service->base.fourcc : 0;
360 mark_service_closing_internal(VCHIQ_SERVICE_T *service, int sh_thread)
362 VCHIQ_STATE_T *state = service->state;
365 service->closing = 1;
380 service_quota = &state->service_quotas[service->localport];
385 mark_service_closing(VCHIQ_SERVICE_T *service)
387 mark_service_closing_internal(service, 0);
391 make_service_callback(VCHIQ_SERVICE_T *service, VCHIQ_REASON_T reason,
396 service->state->id, service->localport, reason_names[reason],
398 status = service->base.callback(reason, header, service->handle,
402 "%d: ignoring ERROR from callback to service %x",
403 service->state->id, service->handle);
502 VCHIQ_SERVICE_T *service = state->services[i];
503 if (service &&
504 (service->public_fourcc == fourcc) &&
505 ((service->srvstate == VCHIQ_SRVSTATE_LISTENING) ||
506 ((service->srvstate == VCHIQ_SRVSTATE_OPEN) &&
507 (service->remoteport == VCHIQ_PORT_FREE)))) {
508 lock_service(service);
509 return service;
522 VCHIQ_SERVICE_T *service = state->services[i];
523 if (service && (service->srvstate == VCHIQ_SRVSTATE_OPEN)
524 && (service->remoteport == port)) {
525 lock_service(service);
526 return service;
533 request_poll(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service, int poll_type)
537 if (service) {
539 value = atomic_read(&service->poll_flags);
540 } while (atomic_cmpxchg(&service->poll_flags, value,
545 service->localport>>5]);
547 &state->poll_services[service->localport>>5],
548 value, value | (1 << (service->localport & 0x1f)))
670 /* Signal the service that it
676 "service %d "
690 /* Set the found bit for this service */
701 /* Signal the service in case
716 "service %d "
767 queue_message(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service,
791 BUG_ON(!service);
795 if (service->closing) {
796 /* The service has been closed */
801 service_quota = &state->service_quotas[service->localport];
805 /* Ensure this service doesn't use more than its quota of
843 state->id, service->localport,
847 VCHIQ_SERVICE_STATS_INC(service, quota_stalls);
852 if (service->closing)
856 if (service->srvstate != VCHIQ_SRVSTATE_OPEN) {
857 /* The service has been closed */
872 if (service)
873 VCHIQ_SERVICE_STATS_INC(service, slot_stalls);
895 BUG_ON(!service);
907 VCHIQ_SERVICE_STATS_INC(service,
913 if (SRVTRACE_ENABLED(service,
926 ** service, the data_use_count must be increased. */
932 /* If this isn't the same slot last used by this service,
933 ** the service's slot_use_count must be increased. */
946 state->id, service->localport,
950 VCHIQ_SERVICE_STATS_INC(service, ctrl_tx_count);
951 VCHIQ_SERVICE_STATS_ADD(service, ctrl_tx_bytes, size);
973 svc_fourcc = service
974 ? service->base.fourcc
977 vchiq_log_info(SRVTRACE_LEVEL(service),
994 if (service && (type == VCHIQ_MSG_CLOSE))
995 vchiq_set_service_state(service, VCHIQ_SRVSTATE_CLOSESENT);
1007 queue_message_sync(VCHIQ_STATE_T *state, VCHIQ_SERVICE_T *service,
1035 if (service) {
1053 VCHIQ_SERVICE_STATS_INC(service,
1064 VCHIQ_SERVICE_STATS_INC(service, ctrl_tx_count);
1065 VCHIQ_SERVICE_STATS_ADD(service, ctrl_tx_bytes, size);
1087 svc_fourcc = service
1088 ? service->base.fourcc
1120 VCHIQ_HEADER_T *header, VCHIQ_SERVICE_T *service)
1129 (service && service->closing)) {
1171 notify_bulks(VCHIQ_SERVICE_T *service, VCHIQ_BULK_QUEUE_T *queue,
1178 service->state->id, service->localport,
1179 (queue == &service->bulk_tx) ? 't' : 'r',
1182 if (service->state->is_master) {
1188 int msgid = VCHIQ_MAKE_MSG(msgtype, service->localport,
1189 service->remoteport);
1193 status = queue_message(service->state, NULL,
1211 if (bulk->data && service->instance) {
1214 VCHIQ_SERVICE_STATS_INC(service,
1216 VCHIQ_SERVICE_STATS_ADD(service,
1220 VCHIQ_SERVICE_STATS_INC(service,
1222 VCHIQ_SERVICE_STATS_ADD(service,
1227 VCHIQ_SERVICE_STATS_INC(service,
1251 status = make_service_callback(service,
1259 up(&service->bulk_remove_event);
1266 request_poll(service->state, service,
1267 (queue == &service->bulk_tx) ?
1284 VCHIQ_SERVICE_T *service =
1289 if (!service)
1292 atomic_xchg(&service->poll_flags, 0);
1297 state->id, service->localport,
1298 service->remoteport);
1303 service->public_fourcc =
1307 service, 0/*!close_recvd*/) !=
1309 request_poll(state, service,
1315 state->id, service->localport,
1316 service->remoteport);
1318 service, 0/*!close_recvd*/) !=
1320 request_poll(state, service,
1324 notify_bulks(service,
1325 &service->bulk_tx,
1328 notify_bulks(service,
1329 &service->bulk_rx,
1331 unlock_service(service);
1339 resolve_bulks(VCHIQ_SERVICE_T *service, VCHIQ_BULK_QUEUE_T *queue)
1341 VCHIQ_STATE_T *state = service->state;
1351 state->id, service->localport,
1352 (queue == &service->bulk_tx) ? 't' : 'r',
1366 if (SRVTRACE_ENABLED(service, VCHIQ_LOG_INFO)) {
1367 const char *header = (queue == &service->bulk_tx) ?
1370 vchiq_log_info(SRVTRACE_LEVEL(service),
1374 service->base.fourcc),
1375 service->remoteport,
1380 vchiq_log_info(SRVTRACE_LEVEL(service),
1385 service->base.fourcc),
1386 service->remoteport,
1402 abort_outstanding_bulks(VCHIQ_SERVICE_T *service, VCHIQ_BULK_QUEUE_T *queue)
1404 int is_tx = (queue == &service->bulk_tx);
1407 service->state->id, service->localport, is_tx ? 't' : 'r',
1427 vchiq_log_info(SRVTRACE_LEVEL(service),
1431 VCHIQ_FOURCC_AS_4CHARS(service->base.fourcc),
1432 service->remoteport,
1482 * in case we've had something come and close the service in the
1488 VCHIQ_SERVICE_T *service = state->services[i];
1491 if (!service || (service->srvstate != VCHIQ_SRVSTATE_OPEN))
1494 lmutex_lock(&service->bulk_mutex);
1495 resolved_rx = resolve_bulks(service, &service->bulk_rx);
1496 resolved_tx = resolve_bulks(service, &service->bulk_tx);
1497 lmutex_unlock(&service->bulk_mutex);
1499 notify_bulks(service, &service->bulk_rx, 1);
1501 notify_bulks(service, &service->bulk_tx, 1);
1509 VCHIQ_SERVICE_T *service = NULL;
1530 service = get_listening_service(state, fourcc);
1532 if (service) {
1533 /* A matching service exists */
1536 if ((service->version < version_min) ||
1537 (version < service->version_min)) {
1540 vchiq_loud_error("%d: service %d (%c%c%c%c) "
1543 state->id, service->localport,
1545 service->version, service->version_min,
1548 unlock_service(service);
1549 service = NULL;
1552 service->peer_version = version;
1554 if (service->srvstate == VCHIQ_SRVSTATE_LISTENING) {
1556 service->version
1565 service->sync = 0;
1568 if (service->sync &&
1574 service->localport,
1583 service->localport,
1590 /* The service is now open */
1591 vchiq_set_service_state(service,
1592 service->sync ? VCHIQ_SRVSTATE_OPENSYNC
1596 service->remoteport = remoteport;
1597 service->client_id = ((int *)header->data)[1];
1598 if (make_service_callback(service, VCHIQ_SERVICE_OPENED,
1601 service->remoteport = VCHIQ_PORT_FREE;
1606 unlock_service(service);
1612 /* No available service, or an invalid request - send a CLOSE */
1621 if (service)
1622 unlock_service(service);
1632 VCHIQ_SERVICE_T *service = NULL;
1683 service = find_service_by_port(state, localport);
1684 if ((!service ||
1685 ((service->remoteport != remoteport) &&
1686 (service->remoteport != VCHIQ_PORT_FREE))) &&
1691 the connected service */
1692 if (service)
1693 unlock_service(service);
1694 service = get_connected_service(state,
1696 if (service)
1699 "found connected service %d",
1703 service->localport);
1706 if (!service) {
1709 "invalid/closed service %d",
1720 if (SRVTRACE_ENABLED(service, VCHIQ_LOG_INFO)) {
1723 svc_fourcc = service
1724 ? service->base.fourcc
1726 vchiq_log_info(SRVTRACE_LEVEL(service),
1758 service->peer_version = payload->version;
1763 remoteport, localport, service->peer_version);
1764 if (service->srvstate ==
1766 service->remoteport = remoteport;
1767 vchiq_set_service_state(service,
1769 up(&service->remove_event);
1773 srvstate_names[service->srvstate]);
1783 mark_service_closing_internal(service, 1);
1785 if (vchiq_close_service_internal(service,
1791 VCHIQ_FOURCC_AS_4CHARS(service->base.fourcc),
1792 service->localport,
1793 service->remoteport);
1801 if ((service->remoteport == remoteport)
1802 && (service->srvstate ==
1807 if (make_service_callback(service,
1813 VCHIQ_SERVICE_STATS_INC(service, ctrl_rx_count);
1814 VCHIQ_SERVICE_STATS_ADD(service, ctrl_rx_bytes,
1833 &service->bulk_tx : &service->bulk_rx;
1834 if ((service->remoteport == remoteport)
1835 && (service->srvstate ==
1842 &service->bulk_mutex) != 0) {
1884 resolved = resolve_bulks(service,
1888 lmutex_unlock(&service->bulk_mutex);
1890 notify_bulks(service, queue,
1897 if ((service->remoteport == remoteport)
1898 && (service->srvstate !=
1904 &service->bulk_rx : &service->bulk_tx;
1908 &service->bulk_mutex) != 0) {
1922 lmutex_unlock(&service->bulk_mutex);
1953 lmutex_unlock(&service->bulk_mutex);
1955 notify_bulks(service, queue, 1/*retry_poll*/);
2020 if (service) {
2021 unlock_service(service);
2022 service = NULL;
2038 if (service)
2039 unlock_service(service);
2066 /* Handle service polling and other rare conditions here
2163 VCHIQ_SERVICE_T *service;
2178 service = find_service_by_port(state, localport);
2180 if (!service) {
2183 "invalid/closed service %d",
2194 svc_fourcc = service
2195 ? service->base.fourcc
2213 service->peer_version = payload->version;
2218 remoteport, localport, service->peer_version);
2219 if (service->srvstate == VCHIQ_SRVSTATE_OPENING) {
2220 service->remoteport = remoteport;
2221 vchiq_set_service_state(service,
2223 service->sync = 1;
2224 up(&service->remove_event);
2235 if ((service->remoteport == remoteport) &&
2236 (service->srvstate ==
2238 if (make_service_callback(service,
2243 "service %d returns "
2257 unlock_service(service);
2556 /* Called from application thread when a client or server service is created. */
2562 VCHIQ_SERVICE_T *service;
2564 service = kmalloc(sizeof(VCHIQ_SERVICE_T), GFP_KERNEL);
2565 if (service) {
2566 service->base.fourcc = params->fourcc;
2567 service->base.callback = params->callback;
2568 service->base.userdata = params->userdata;
2569 service->handle = VCHIQ_SERVICE_HANDLE_INVALID;
2570 service->ref_count = 1;
2571 service->srvstate = VCHIQ_SRVSTATE_FREE;
2572 service->userdata_term = userdata_term;
2573 service->localport = VCHIQ_PORT_FREE;
2574 service->remoteport = VCHIQ_PORT_FREE;
2576 service->public_fourcc = (srvstate == VCHIQ_SRVSTATE_OPENING) ?
2578 service->client_id = 0;
2579 service->auto_close = 1;
2580 service->sync = 0;
2581 service->closing = 0;
2582 service->trace = 0;
2583 atomic_set(&service->poll_flags, 0);
2584 service->version = params->version;
2585 service->version_min = params->version_min;
2586 service->state = state;
2587 service->instance = instance;
2588 service->service_use_count = 0;
2589 init_bulk_queue(&service->bulk_tx);
2590 init_bulk_queue(&service->bulk_rx);
2591 _sema_init(&service->remove_event, 0);
2592 _sema_init(&service->bulk_remove_event, 0);
2593 lmutex_init(&service->bulk_mutex);
2594 memset(&service->stats, 0, sizeof(service->stats));
2600 if (service) {
2608 ** service - service deletion is safe.
2616 /* Prepare to use a previously unused service */
2646 service->localport = (pservice - state->services);
2650 service->handle = handle_seq |
2652 service->localport;
2654 *pservice = service;
2662 _sema_destroy(&service->remove_event);
2663 _sema_destroy(&service->bulk_remove_event);
2664 lmutex_destroy(&service->bulk_mutex);
2666 kfree(service);
2667 service = NULL;
2671 if (service) {
2673 &state->service_quotas[service->localport];
2681 /* Bring this service online */
2682 vchiq_set_service_state(service, srvstate);
2689 service->localport);
2692 /* Don't unlock the service - leave it with a ref_count of 1. */
2694 return service;
2698 vchiq_open_service_internal(VCHIQ_SERVICE_T *service, int client_id)
2701 service->base.fourcc,
2703 service->version,
2704 service->version_min
2709 service->client_id = client_id;
2710 vchiq_use_service_internal(service);
2711 status = queue_message(service->state, NULL,
2712 VCHIQ_MAKE_MSG(VCHIQ_MSG_OPEN, service->localport, 0),
2716 if (down_interruptible(&service->remove_event) != 0) {
2718 vchiq_release_service_internal(service);
2719 } else if ((service->srvstate != VCHIQ_SRVSTATE_OPEN) &&
2720 (service->srvstate != VCHIQ_SRVSTATE_OPENSYNC)) {
2721 if (service->srvstate != VCHIQ_SRVSTATE_CLOSEWAIT)
2724 service->state->id,
2725 srvstate_names[service->srvstate],
2726 service->ref_count);
2728 VCHIQ_SERVICE_STATS_INC(service, error_count);
2729 vchiq_release_service_internal(service);
2736 release_service_messages(VCHIQ_SERVICE_T *service)
2738 VCHIQ_STATE_T *state = service->state;
2742 /* Release any claimed messages aimed at this service */
2744 if (service->sync) {
2748 if (VCHIQ_MSG_DSTPORT(header->msgid) == service->localport)
2775 if ((port == service->localport) &&
2800 do_abort_bulks(VCHIQ_SERVICE_T *service)
2805 if (lmutex_lock_interruptible(&service->bulk_mutex) != 0)
2807 abort_outstanding_bulks(service, &service->bulk_tx);
2808 abort_outstanding_bulks(service, &service->bulk_rx);
2809 lmutex_unlock(&service->bulk_mutex);
2811 status = notify_bulks(service, &service->bulk_tx, 0/*!retry_poll*/);
2813 status = notify_bulks(service, &service->bulk_rx,
2819 close_service_complete(VCHIQ_SERVICE_T *service, int failstate)
2822 int is_server = (service->public_fourcc != VCHIQ_FOURCC_INVALID);
2825 switch (service->srvstate) {
2830 if (service->auto_close) {
2831 service->client_id = 0;
2832 service->remoteport = VCHIQ_PORT_FREE;
2838 vchiq_set_service_state(service, newstate);
2845 service->handle, srvstate_names[service->srvstate]);
2850 status = make_service_callback(service,
2854 int uc = service->service_use_count;
2860 vchiq_release_service_internal(service);
2862 service->client_id = 0;
2863 service->remoteport = VCHIQ_PORT_FREE;
2865 if (service->srvstate == VCHIQ_SRVSTATE_CLOSED)
2866 vchiq_free_service_internal(service);
2867 else if (service->srvstate != VCHIQ_SRVSTATE_CLOSEWAIT) {
2869 service->closing = 0;
2871 up(&service->remove_event);
2874 vchiq_set_service_state(service, failstate);
2881 vchiq_close_service_internal(VCHIQ_SERVICE_T *service, int close_recvd)
2883 VCHIQ_STATE_T *state = service->state;
2885 int is_server = (service->public_fourcc != VCHIQ_FOURCC_INVALID);
2888 service->state->id, service->localport, close_recvd,
2889 srvstate_names[service->srvstate]);
2891 switch (service->srvstate) {
2900 srvstate_names[service->srvstate]);
2902 if (service->srvstate == VCHIQ_SRVSTATE_LISTENING) {
2905 service->client_id = 0;
2906 service->remoteport = VCHIQ_PORT_FREE;
2907 if (service->srvstate ==
2909 vchiq_set_service_state(service,
2912 up(&service->remove_event);
2914 vchiq_free_service_internal(service);
2919 vchiq_set_service_state(service,
2921 up(&service->remove_event);
2924 status = queue_message(state, service,
2927 service->localport,
2928 VCHIQ_MSG_DSTPORT(service->remoteport)),
2939 if (!do_abort_bulks(service))
2943 release_service_messages(service);
2946 status = queue_message(state, service,
2949 service->localport,
2950 VCHIQ_MSG_DSTPORT(service->remoteport)),
2957 vchiq_set_service_state(service,
2960 if (service->sync)
2964 } else if (service->srvstate == VCHIQ_SRVSTATE_OPENSYNC) {
2971 vchiq_set_service_state(service, VCHIQ_SRVSTATE_CLOSERECVD);
2973 if (service->sync)
2976 status = close_service_complete(service,
2986 if (!do_abort_bulks(service)) {
2993 status = close_service_complete(service,
3000 vchiq_set_service_state(service,
3002 status = close_service_complete(service,
3009 close_recvd, srvstate_names[service->srvstate]);
3018 vchiq_terminate_service_internal(VCHIQ_SERVICE_T *service)
3020 VCHIQ_STATE_T *state = service->state;
3023 state->id, service->localport, service->remoteport);
3025 mark_service_closing(service);
3027 /* Mark the service for removal by the slot handler */
3028 request_poll(state, service, VCHIQ_POLL_REMOVE);
3033 vchiq_free_service_internal(VCHIQ_SERVICE_T *service)
3035 VCHIQ_STATE_T *state = service->state;
3038 state->id, service->localport);
3040 switch (service->srvstate) {
3050 state->id, service->localport,
3051 srvstate_names[service->srvstate]);
3055 vchiq_set_service_state(service, VCHIQ_SRVSTATE_FREE);
3057 up(&service->remove_event);
3060 unlock_service(service);
3066 VCHIQ_SERVICE_T *service;
3071 while ((service = next_service_by_instance(state, instance,
3073 if (service->srvstate == VCHIQ_SRVSTATE_HIDDEN)
3074 vchiq_set_service_state(service,
3076 unlock_service(service);
3102 VCHIQ_SERVICE_T *service;
3107 while ((service = next_service_by_instance(state, instance,
3109 (void)vchiq_remove_service(service->handle);
3110 unlock_service(service);
3158 /* Unregister the service */
3159 VCHIQ_SERVICE_T *service = find_service_by_handle(handle);
3162 if (!service)
3167 service->state->id, service->localport);
3169 if ((service->srvstate == VCHIQ_SRVSTATE_FREE) ||
3170 (service->srvstate == VCHIQ_SRVSTATE_LISTENING) ||
3171 (service->srvstate == VCHIQ_SRVSTATE_HIDDEN)) {
3172 unlock_service(service);
3176 mark_service_closing(service);
3178 if (current == service->state->slot_handler_thread) {
3179 status = vchiq_close_service_internal(service,
3183 /* Mark the service for termination by the slot handler */
3184 request_poll(service->state, service, VCHIQ_POLL_TERMINATE);
3188 if (down_interruptible(&service->remove_event) != 0) {
3193 if ((service->srvstate == VCHIQ_SRVSTATE_FREE) ||
3194 (service->srvstate == VCHIQ_SRVSTATE_LISTENING) ||
3195 (service->srvstate == VCHIQ_SRVSTATE_OPEN))
3200 service->state->id, service->localport,
3201 srvstate_names[service->srvstate]);
3205 (service->srvstate != VCHIQ_SRVSTATE_FREE) &&
3206 (service->srvstate != VCHIQ_SRVSTATE_LISTENING))
3209 unlock_service(service);
3217 /* Unregister the service */
3218 VCHIQ_SERVICE_T *service = find_service_by_handle(handle);
3221 if (!service)
3226 service->state->id, service->localport);
3228 if (service->srvstate == VCHIQ_SRVSTATE_FREE) {
3229 unlock_service(service);
3233 mark_service_closing(service);
3235 if ((service->srvstate == VCHIQ_SRVSTATE_HIDDEN) ||
3236 (current == service->state->slot_handler_thread)) {
3239 service->public_fourcc = VCHIQ_FOURCC_INVALID;
3241 status = vchiq_close_service_internal(service,
3245 /* Mark the service for removal by the slot handler */
3246 request_poll(service->state, service, VCHIQ_POLL_REMOVE);
3249 if (down_interruptible(&service->remove_event) != 0) {
3254 if ((service->srvstate == VCHIQ_SRVSTATE_FREE) ||
3255 (service->srvstate == VCHIQ_SRVSTATE_OPEN))
3260 service->state->id, service->localport,
3261 srvstate_names[service->srvstate]);
3265 (service->srvstate != VCHIQ_SRVSTATE_FREE))
3268 unlock_service(service);
3286 VCHIQ_SERVICE_T *service = find_service_by_handle(handle);
3296 if (!service ||
3297 (service->srvstate != VCHIQ_SRVSTATE_OPEN) ||
3299 (vchiq_check_service(service) != VCHIQ_SUCCESS))
3320 state = service->state;
3323 &service->bulk_tx : &service->bulk_rx;
3325 if (lmutex_lock_interruptible(&service->bulk_mutex) != 0) {
3331 VCHIQ_SERVICE_STATS_INC(service, bulk_stalls);
3333 lmutex_unlock(&service->bulk_mutex);
3334 if (down_interruptible(&service->bulk_remove_event)
3339 if (lmutex_lock_interruptible(&service->bulk_mutex)
3365 service->localport, service->remoteport, dir_char,
3368 /* The slot mutex must be held when the service is being closed, so
3375 if (service->srvstate != VCHIQ_SRVSTATE_OPEN)
3380 if (resolve_bulks(service, queue))
3381 request_poll(state, service,
3390 service->localport, service->remoteport),
3402 lmutex_unlock(&service->bulk_mutex);
3407 service->localport, dir_char,
3411 unlock_service(service);
3430 lmutex_unlock(&service->bulk_mutex);
3433 if (service)
3434 unlock_service(service);
3442 VCHIQ_SERVICE_T *service = find_service_by_handle(handle);
3448 if (!service ||
3449 (vchiq_check_service(service) != VCHIQ_SUCCESS))
3455 VCHIQ_SERVICE_STATS_INC(service, error_count);
3463 VCHIQ_SERVICE_STATS_INC(service, error_count);
3467 switch (service->srvstate) {
3469 status = queue_message(service->state, service,
3471 service->localport,
3472 service->remoteport),
3476 status = queue_message_sync(service->state, service,
3478 service->localport,
3479 service->remoteport),
3488 if (service)
3489 unlock_service(service);
3497 VCHIQ_SERVICE_T *service = find_service_by_handle(handle);
3502 if (!service)
3505 state = service->state;
3517 release_slot(state, slot_info, header, service);
3522 unlock_service(service);
3537 VCHIQ_SERVICE_T *service = find_service_by_handle(handle);
3539 if (!service ||
3540 (vchiq_check_service(service) != VCHIQ_SUCCESS) ||
3543 *peer_version = service->peer_version;
3547 if (service)
3548 unlock_service(service);
3580 VCHIQ_SERVICE_T *service = find_service_by_handle(handle);
3583 if (service) {
3586 service->auto_close = value;
3592 &service->state->service_quotas[
3593 service->localport];
3595 value = service->state->default_slot_quota;
3602 /* Signal the service that it may have
3612 &service->state->service_quotas[
3613 service->localport];
3615 value = service->state->default_message_quota;
3623 /* Signal the service that it may have
3631 if ((service->srvstate == VCHIQ_SRVSTATE_HIDDEN) ||
3632 (service->srvstate ==
3634 service->sync = value;
3640 service->trace = value;
3647 unlock_service(service);
3754 VCHIQ_SERVICE_T *service = find_service_by_port(state, i);
3756 if (service) {
3757 vchiq_dump_service_state(dump_context, service);
3758 unlock_service(service);
3764 vchiq_dump_service_state(void *dump_context, VCHIQ_SERVICE_T *service)
3770 service->localport, srvstate_names[service->srvstate],
3771 service->ref_count - 1); /*Don't include the lock just taken*/
3773 if (service->srvstate != VCHIQ_SRVSTATE_FREE) {
3776 &service->state->service_quotas[service->localport];
3777 int fourcc = service->base.fourcc;
3779 if (service->remoteport != VCHIQ_PORT_FREE) {
3781 "%d", service->remoteport);
3782 if (service->public_fourcc != VCHIQ_FOURCC_INVALID)
3785 " (client %8x)", service->client_id);
3800 tx_pending = service->bulk_tx.local_insert -
3801 service->bulk_tx.remote_insert;
3803 rx_pending = service->bulk_rx.local_insert -
3804 service->bulk_rx.remote_insert;
3810 tx_pending ? service->bulk_tx.bulks[
3811 BULK_INDEX(service->bulk_tx.remove)].size : 0,
3813 rx_pending ? service->bulk_rx.bulks[
3814 BULK_INDEX(service->bulk_rx.remove)].size : 0);
3822 service->stats.ctrl_tx_count,
3823 service->stats.ctrl_tx_bytes,
3824 service->stats.ctrl_rx_count,
3825 service->stats.ctrl_rx_bytes);
3831 service->stats.bulk_tx_count,
3832 service->stats.bulk_tx_bytes,
3833 service->stats.bulk_rx_count,
3834 service->stats.bulk_rx_bytes);
3840 service->stats.quota_stalls,
3841 service->stats.slot_stalls,
3842 service->stats.bulk_stalls,
3843 service->stats.bulk_aborted_count,
3844 service->stats.error_count);
3850 if (service->srvstate != VCHIQ_SRVSTATE_FREE)
3851 vchiq_dump_platform_service_state(dump_context, service);