Am 21.06.2013 19:13, schrieb ronnie sahlberg:
> On Fri, Jun 21, 2013 at 10:06 AM, Peter Lieven <p...@kamp.de> wrote:
>> Am 21.06.2013 18:31, schrieb Paolo Bonzini:
>>> Il 21/06/2013 13:07, Kevin Wolf ha scritto:
>>>>>>>> Note that you're blocking here. The preferred way would be something
>>>>>>>> involving a yield from the coroutine and a reenter as soon as all
>>>>>>>> requests are done. Maybe a CoRwLock does what you need?
>>>>>> Is there a document how to use it? Or can you help here?
>>>> The idea would be to take a read lock while any request is in flight
>>>> (i.e. qemu_co_rwlock_rdlock() before it's started and
>>>> qemu_co_rwlock_unlock() when it completes), and to take a write lock
>>>> (qemu_co_rwlock_wrlock) for the part of iscsi_co_is_allocated() that
>>>> requires that no other request runs in parallel.
>>>>
>>> You can just send the SCSI command asynchronously and wait for the
>>> result. There is an example in block/qed.c, the same would apply for iscsi.
>> thanks for the pointer paolo, this was i was looking for. this here seems to
>> work:
>>
>> static void
>> iscsi_co_is_allocated_cb(struct iscsi_context *iscsi, int status,
>> void *command_data, void *opaque)
>> {
>> struct IscsiTask *iTask = opaque;
>> struct scsi_task *task = command_data;
>> struct scsi_get_lba_status *lbas = NULL;
>>
>> iTask->complete = 1;
>>
>> if (status != 0) {
>> error_report("iSCSI: Failed to get_lba_status on iSCSI lun. %s",
>> iscsi_get_error(iscsi));
>> iTask->status = 1;
>> goto out;
>> }
>>
>> lbas = scsi_datain_unmarshall(task);
>> if (lbas == NULL) {
>> iTask->status = 1;
>> goto out;
>> }
>>
>> memcpy(&iTask->lbasd, &lbas->descriptors[0],
>> sizeof(struct scsi_lba_status_descriptor));
> Only the first descriptor?
> sector_num -> sector_num+nb_sectors could be partially allocated in
> which case you get multiple descriptors.
The number of sectors for which the returned provisioning state
holds true is set in *pnum. If it is only partly allocated the
return value of iscsi_co_is_allocated will be 1 or 0 and pnum
returns the number of sectors for which this is true.
>> iTask->status = 0;
>>
>> out:
>> scsi_free_scsi_task(task);
>>
>> if (iTask->co) {
>> qemu_coroutine_enter(iTask->co, NULL);
>> }
>> }
>>
>> static int coroutine_fn iscsi_co_is_allocated(BlockDriverState *bs,
>> int64_t sector_num,
>> int nb_sectors, int *pnum)
>> {
>> IscsiLun *iscsilun = bs->opaque;
>> struct IscsiTask iTask;
>> int ret;
>>
>> *pnum = nb_sectors;
>>
>> if (iscsilun->lbpme == 0) {
>> return 1;
>> }
>>
>> iTask.iscsilun = iscsilun;
>> iTask.status = 0;
>> iTask.complete = 0;
>> iTask.bs = bs;
>>
>> if (iscsi_get_lba_status_task(iscsilun->iscsi, iscsilun->lun,
>> sector_qemu2lun(sector_num, iscsilun),
>> 8 + 16, iscsi_co_is_allocated_cb,
>> &iTask) == NULL) {
>> *pnum = 0;
>> return 0;
>> }
>>
>> while (!iTask.complete) {
>> iscsi_set_events(iscsilun);
>> iTask.co = qemu_coroutine_self();
>> qemu_coroutine_yield();
>> }
>>
>> if (iTask.status != 0) {
>> /* in case the get_lba_status_callout fails (i.e.
>> * because the device is busy or the cmd is not
>> * supported) we pretend all blocks are allocated
>> * for backwards compatiblity */
>> return 1;
>> }
>>
>> if (sector_qemu2lun(sector_num, iscsilun) != iTask.lbasd.lba) {
>> *pnum = 0;
>> return 0;
>> }
>>
>> *pnum = iTask.lbasd.num_blocks * (iscsilun->block_size /
>> BDRV_SECTOR_SIZE);
>> if (*pnum > nb_sectors) {
>> *pnum = nb_sectors;
>> }
>>
>> return (iTask.lbasd.provisioning == SCSI_PROVISIONING_TYPE_MAPPED) ? 1 :
>> 0;
>>
>> return ret;
>> }
