Lines Matching full:request
293 __tape_cancel_io(struct tape_device *device, struct tape_request *request) in __tape_cancel_io() argument
299 if (request->callback == NULL) in __tape_cancel_io()
304 rc = ccw_device_clear(device->cdev, (long) request); in __tape_cancel_io()
308 request->status = TAPE_REQUEST_DONE; in __tape_cancel_io()
311 request->status = TAPE_REQUEST_CANCEL; in __tape_cancel_io()
435 * request. We may prevent this by returning an error.
593 struct tape_request * request; in __tape_discard_requests() local
597 request = list_entry(l, struct tape_request, list); in __tape_discard_requests()
598 if (request->status == TAPE_REQUEST_IN_IO) in __tape_discard_requests()
599 request->status = TAPE_REQUEST_DONE; in __tape_discard_requests()
600 list_del(&request->list); in __tape_discard_requests()
602 /* Decrease ref_count for removed request. */ in __tape_discard_requests()
603 request->device = NULL; in __tape_discard_requests()
605 request->rc = -EIO; in __tape_discard_requests()
606 if (request->callback != NULL) in __tape_discard_requests()
607 request->callback(request, request->callback_data); in __tape_discard_requests()
650 * an interrupt for a request that was running. So we in tape_generic_remove()
672 * Allocate a new tape ccw request
677 struct tape_request *request; in tape_alloc_request() local
683 request = kzalloc(sizeof(struct tape_request), GFP_KERNEL); in tape_alloc_request()
684 if (request == NULL) { in tape_alloc_request()
690 request->cpaddr = kcalloc(cplength, sizeof(struct ccw1), in tape_alloc_request()
692 if (request->cpaddr == NULL) { in tape_alloc_request()
694 kfree(request); in tape_alloc_request()
700 request->cpdata = kzalloc(datasize, GFP_KERNEL | GFP_DMA); in tape_alloc_request()
701 if (request->cpdata == NULL) { in tape_alloc_request()
703 kfree(request->cpaddr); in tape_alloc_request()
704 kfree(request); in tape_alloc_request()
708 DBF_LH(6, "New request %p(%p/%p)\n", request, request->cpaddr, in tape_alloc_request()
709 request->cpdata); in tape_alloc_request()
711 return request; in tape_alloc_request()
715 * Free tape ccw request
718 tape_free_request (struct tape_request * request) in tape_free_request() argument
720 DBF_LH(6, "Free request %p\n", request); in tape_free_request()
722 if (request->device) in tape_free_request()
723 tape_put_device(request->device); in tape_free_request()
724 kfree(request->cpdata); in tape_free_request()
725 kfree(request->cpaddr); in tape_free_request()
726 kfree(request); in tape_free_request()
730 __tape_start_io(struct tape_device *device, struct tape_request *request) in __tape_start_io() argument
736 request->cpaddr, in __tape_start_io()
737 (unsigned long) request, in __tape_start_io()
739 request->options in __tape_start_io()
742 request->status = TAPE_REQUEST_IN_IO; in __tape_start_io()
745 request->status = TAPE_REQUEST_QUEUED; in __tape_start_io()
749 /* Start failed. Remove request and indicate failure. */ in __tape_start_io()
750 DBF_EVENT(1, "tape: start request failed with RC = %i\n", rc); in __tape_start_io()
759 struct tape_request *request; in __tape_start_next_request() local
764 * Try to start each request on request queue until one is in __tape_start_next_request()
768 request = list_entry(l, struct tape_request, list); in __tape_start_next_request()
774 if (request->status == TAPE_REQUEST_IN_IO) in __tape_start_next_request()
777 * Request has already been stopped. We have to wait until in __tape_start_next_request()
778 * the request is removed from the queue in the interrupt in __tape_start_next_request()
781 if (request->status == TAPE_REQUEST_DONE) in __tape_start_next_request()
785 * We wanted to cancel the request but the common I/O layer in __tape_start_next_request()
788 * Otherwise we start the next request on the queue. in __tape_start_next_request()
790 if (request->status == TAPE_REQUEST_CANCEL) { in __tape_start_next_request()
791 rc = __tape_cancel_io(device, request); in __tape_start_next_request()
793 rc = __tape_start_io(device, request); in __tape_start_next_request()
799 request->rc = rc; in __tape_start_next_request()
800 request->status = TAPE_REQUEST_DONE; in __tape_start_next_request()
802 /* Remove from request queue. */ in __tape_start_next_request()
803 list_del(&request->list); in __tape_start_next_request()
806 if (request->callback != NULL) in __tape_start_next_request()
807 request->callback(request, request->callback_data); in __tape_start_next_request()
826 struct tape_request *request; in tape_long_busy_timeout() local
829 request = list_entry(device->req_queue.next, struct tape_request, list); in tape_long_busy_timeout()
830 BUG_ON(request->status != TAPE_REQUEST_LONG_BUSY); in tape_long_busy_timeout()
840 struct tape_request * request, in __tape_end_request() argument
843 DBF_LH(6, "__tape_end_request(%p, %p, %i)\n", device, request, rc); in __tape_end_request()
844 if (request) { in __tape_end_request()
845 request->rc = rc; in __tape_end_request()
846 request->status = TAPE_REQUEST_DONE; in __tape_end_request()
848 /* Remove from request queue. */ in __tape_end_request()
849 list_del(&request->list); in __tape_end_request()
852 if (request->callback != NULL) in __tape_end_request()
853 request->callback(request, request->callback_data); in __tape_end_request()
856 /* Start next request. */ in __tape_end_request()
865 tape_dump_sense_dbf(struct tape_device *device, struct tape_request *request, in tape_dump_sense_dbf() argument
871 if (request != NULL) in tape_dump_sense_dbf()
872 op = tape_op_verbose[request->op]; in tape_dump_sense_dbf()
886 * I/O helper function. Adds the request to the request queue
891 __tape_start_request(struct tape_device *device, struct tape_request *request) in __tape_start_request() argument
895 switch (request->op) { in __tape_start_request()
913 /* Increase use count of device for the added request. */ in __tape_start_request()
914 request->device = tape_get_device(device); in __tape_start_request()
918 rc = __tape_start_io(device, request); in __tape_start_request()
922 DBF_LH(5, "Request %p added for execution.\n", request); in __tape_start_request()
923 list_add(&request->list, &device->req_queue); in __tape_start_request()
925 DBF_LH(5, "Request %p add to queue.\n", request); in __tape_start_request()
926 request->status = TAPE_REQUEST_QUEUED; in __tape_start_request()
927 list_add_tail(&request->list, &device->req_queue); in __tape_start_request()
933 * Add the request to the request queue, try to start it if the
937 tape_do_io_async(struct tape_device *device, struct tape_request *request) in tape_do_io_async() argument
941 DBF_LH(6, "tape_do_io_async(%p, %p)\n", device, request); in tape_do_io_async()
944 /* Add request to request queue and try to start it. */ in tape_do_io_async()
945 rc = __tape_start_request(device, request); in tape_do_io_async()
952 * Add the request to the request queue, try to start it if the
956 __tape_wake_up(struct tape_request *request, void *data) in __tape_wake_up() argument
958 request->callback = NULL; in __tape_wake_up()
963 tape_do_io(struct tape_device *device, struct tape_request *request) in tape_do_io() argument
969 request->callback = __tape_wake_up; in tape_do_io()
970 request->callback_data = &device->wait_queue; in tape_do_io()
971 /* Add request to request queue and try to start it. */ in tape_do_io()
972 rc = __tape_start_request(device, request); in tape_do_io()
976 /* Request added to the queue. Wait for its completion. */ in tape_do_io()
977 wait_event(device->wait_queue, (request->callback == NULL)); in tape_do_io()
978 /* Get rc from request */ in tape_do_io()
979 return request->rc; in tape_do_io()
984 * Add the request to the request queue, try to start it if the
988 __tape_wake_up_interruptible(struct tape_request *request, void *data) in __tape_wake_up_interruptible() argument
990 request->callback = NULL; in __tape_wake_up_interruptible()
996 struct tape_request *request) in tape_do_io_interruptible() argument
1002 request->callback = __tape_wake_up_interruptible; in tape_do_io_interruptible()
1003 request->callback_data = &device->wait_queue; in tape_do_io_interruptible()
1004 rc = __tape_start_request(device, request); in tape_do_io_interruptible()
1008 /* Request added to the queue. Wait for its completion. */ in tape_do_io_interruptible()
1010 (request->callback == NULL)); in tape_do_io_interruptible()
1012 /* Request finished normally. */ in tape_do_io_interruptible()
1013 return request->rc; in tape_do_io_interruptible()
1015 /* Interrupted by a signal. We have to stop the current request. */ in tape_do_io_interruptible()
1017 rc = __tape_cancel_io(device, request); in tape_do_io_interruptible()
1024 (request->callback == NULL) in tape_do_io_interruptible()
1038 tape_cancel_io(struct tape_device *device, struct tape_request *request) in tape_cancel_io() argument
1043 rc = __tape_cancel_io(device, request); in tape_cancel_io()
1055 struct tape_request *request; in __tape_do_irq() local
1062 request = (struct tape_request *) intparm; in __tape_do_irq()
1064 DBF_LH(6, "__tape_do_irq(device=%p, request=%p)\n", device, request); in __tape_do_irq()
1068 /* FIXME: What to do with the request? */ in __tape_do_irq()
1071 DBF_LH(1, "(%08x): Request timed out\n", in __tape_do_irq()
1075 __tape_end_request(device, request, -EIO); in __tape_do_irq()
1088 * error might still apply. So we just schedule the request to be in __tape_do_irq()
1093 (request->status == TAPE_REQUEST_IN_IO)) { in __tape_do_irq()
1096 request->status = TAPE_REQUEST_QUEUED; in __tape_do_irq()
1102 if(request != NULL) in __tape_do_irq()
1103 request->rescnt = irb->scsw.cmd.count; in __tape_do_irq()
1127 * Any request that does not come back with channel end in __tape_do_irq()
1131 tape_dump_sense_dbf(device, request, irb); in __tape_do_irq()
1142 * Request that were canceled still come back with an interrupt. in __tape_do_irq()
1143 * To detect these request the state will be set to TAPE_REQUEST_DONE. in __tape_do_irq()
1145 if(request != NULL && request->status == TAPE_REQUEST_DONE) { in __tape_do_irq()
1146 __tape_end_request(device, request, -EIO); in __tape_do_irq()
1150 rc = device->discipline->irq(device, request, irb); in __tape_do_irq()
1152 * rc < 0 : request finished unsuccessfully. in __tape_do_irq()
1153 * rc == TAPE_IO_SUCCESS: request finished successfully. in __tape_do_irq()
1154 * rc == TAPE_IO_PENDING: request is still running. Ignore rc. in __tape_do_irq()
1155 * rc == TAPE_IO_RETRY: request finished but needs another go. in __tape_do_irq()
1156 * rc == TAPE_IO_STOP: request needs to get terminated. in __tape_do_irq()
1162 __tape_end_request(device, request, rc); in __tape_do_irq()
1171 request->status = TAPE_REQUEST_LONG_BUSY; in __tape_do_irq()
1174 rc = __tape_start_io(device, request); in __tape_do_irq()
1176 __tape_end_request(device, request, rc); in __tape_do_irq()
1179 rc = __tape_cancel_io(device, request); in __tape_do_irq()
1181 __tape_end_request(device, request, rc); in __tape_do_irq()
1186 __tape_end_request(device, request, -EIO); in __tape_do_irq()
1188 __tape_end_request(device, request, rc); in __tape_do_irq()