lkml.org 
[lkml]   [2020]   [Oct]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
SubjectRe: [PATCH v3] i2c: virtio: add a virtio i2c frontend driver
From
Date

On 2020/10/14 下午4:37, Jie Deng wrote:
>
> On 2020/10/13 16:00, Jason Wang wrote:
>>
>>>>>>> +
>>>>>>> +        virtqueue_kick(vq);
>>>>>>> +
>>>>>>> +        time_left =
>>>>>>> wait_for_completion_timeout(&vi->completion, adap->timeout);
>>>>>>> +        if (!time_left) {
>>>>>>> +            dev_err(&adap->dev, "msg[%d]: addr=0x%x
>>>>>>> timeout.\n", i, msgs[i].addr);
>>>>>>> +            break;
>>>>>>> +        }
>>>>>>
>>>>>>
>>>>>> You don't set error number here. Is this intended?
>>>>>>
>>>>>> And using a timeout here is not good, and if the request is
>>>>>> finished just after the timeout, in the next xfer you may hit the
>>>>>> following check.
>>>>>>
>>>>>> It's better to use either interrupt here.
>>>>>>
>>>>> Could you check the I2C drivers in the kernel ? The
>>>>> "wait_for_completion_timeout" mechanism
>>>>> is commonly used by I2C bus drivers in their
>>>>> i2c_algorithm.master_xfer.
>>>>
>>>>
>>>> There's a major difference between virtio-i2c and other drivers. In
>>>> the case of virtio, the device could be a software device emulated
>>>> by a remote process. This means the timeout might not be rare.
>>>>
>>>> I don't see how timeout is properly handled in this patch (e.g did
>>>> you notice that you don't set any error when timeout? or is this
>>>> intended?)
>>>>
>>> The backend software may operate the physical device. The timeout
>>> depends on how the backend is designed.
>>> Here if the timeout happens, it will return the actual number of
>>> messages successfully processed to the I2C core.
>>> Let the I2C core decides how to do next.
>>
>>
>> So let's consider the following case:
>>
>> 1) driver:virtio_i2c_add_msg(msgA)
>> 2) driver:timeout, and return to I2C core
>> 3) driver:virtio_i2c_add_msg(msgB)
>> 4) device: complete msgA
>> 5) driver: virtqueue_get_buf() returns msgA, since the token is
>> always vi->vmsg, the driver may think msgB has been completed.
>>
>>
> If this case does happen, it is exactly a case that the condition
> "((!vmsg) || (vmsg != &vi->vmsg))" are met.


I may miss something, but you always use vi->vmsg as token so vmsg is
equal to &vi->vmsg here


> Currently, the timeout value is hard-coded in the driver. Generally
> speaking, timeout rarely happens.


Well, it's better to no have such assumption consider the device could
be a emulated one.


> It can also be designed as a device configuration if needed.


In any case, the timeout should be handled correctly regardless of its
frequency.


>
> Thanks.
>
>>>
>>> Thanks.
>>>
>>>>
>>>>>
>>>>>>
>>>>>>> +
>>>>>>> +        vmsg = (struct virtio_i2c_msg *)virtqueue_get_buf(vq,
>>>>>>> &len);
>>>>>>> +        /* vmsg should point to the same address with &vi->vmsg */
>>>>>>> +        if ((!vmsg) || (vmsg != &vi->vmsg)) {
>>>>>>> +            dev_err(&adap->dev, "msg[%d]: addr=0x%x virtqueue
>>>>>>> error.\n",
>>>>>>> +                i, msgs[i].addr);
>>>>>>> +            break;
>>>>>>> +        }
>>>>>>
>>>>>>
>>>>>> So I think we can remove this check. Consider only one descriptor
>>>>>> will be used at most, unless there's a bug in the device (and no
>>>>>> other driver to the similar check), we should not hit this.
>>>>>>
>>>>>> Btw, as I replied in the previous version, the device should be
>>>>>> cacpable of dealing of a batch of requests through the virtqueue,
>>>>>> otherwise it's meaningless to use a queue here.
>>>>>>
>>>>> We should not assume there is no bug in the device. I don't think
>>>>> we can remove this check if we want our code to be robust.
>>>>
>>>>
>>>> Can you tell when at which case you may hit !vmsg or vmsg != vi->vmsg?
>>>>
>>> Normally, it won't hit here. But the API "virtqueue_get_buf" tells me
>>> "It *may *return NULL or the "data" token handed to virtqueue_add_*()."
>>
>>
>> Note that we had the following check already in
>> virtqueue_get_buf_ctx(), so the the virtio core had already have the
>> ability to figure out the wrong head.
>>
>>     if (unlikely(id >= vq->packed.vring.num)) {
>>         BAD_RING(vq, "id %u out of range\n", id);
>>         return NULL;
>>     }
>>     if (unlikely(!vq->packed.desc_state[id].data)) {
>>         BAD_RING(vq, "id %u is not a head!\n", id);
>>         return NULL;
>>     }
>>
>> And when it returns a NULL, it's not necessarily an error of the
>> device, it might just require more time to finish the processing.
>>
>
> That's why we just returned the actual number of messages successfully
> processed in this case,
> and let the I2C core to try one more time.
>
> Actually we have no idea if this is a device error or not. Try one
> more time can also fail if it is a backend error.
> Of course, there is another option. We can return error for timeout,
> no matter what reason.
>
> Thanks.
>
>
>>
>>>
>>> From the perspective of a caller, I just don't care when it happens.
>>> To make the code robust, what I care about is what I should do if
>>> this is not our case
>>> since the doc says it*may *happen.
>>>
>>> If you insist on removing this check, I will remove "vmsg !=
>>> vi->vmsg" and keep the check for !vmsg.
>>> As Dan reported in v2, we should at least check here for NULL.
>>>
>>> Thanks.
>>>
>>>>
>>>>
>>>>> As I said, currently, we are using the virtqueue to send the msg
>>>>> one by one to the backend. The mechanism is described in the spec.
>>>>
>>>>
>>>> Which part of the spec describes such "one by one" mechanism? If
>>>> there is one, I'd happily give a NACK since it doesn't require a
>>>> queue to work which is conflict with the concept of the virtqueue.
>>>>
>>>>
>>> What's the concept of the virtqueue ?  Why do you want to restrict
>>> how users use virtqueue ?
>>
>>
>> So I think there's some misunderstanding here. The point is not to
>> restrict how to use virtqueue.
>>
>> What I meant is:
>>
>> - we should not invent a device with a virtqueue that can only accept
>> one buffer at a time
>> - I don't see any mechanism like "one by one" described in the spec,
>> so it's ok but if it'd happen to have, I will NACK
>>
>>
> Thanks for your clarification. I didn't restrict how to use the
> virtqueue in the spec.
> The code is just one implementation. I'd like to have this simple
> driver been merged first.
> It may have optimization in the future according to the needs.
>
> Thanks.
>
>
>>>
>>> It's like you provide a water glass to user. The user can fill a
>>> full glass of water and drinks once or
>>> fill half a glass of water and drink twice. It is a user behavior
>>> and should not be restricted by
>>> the glass provider.
>>
>>
>> That's my point as well, we should not describe the "once" behavior
>> in the spec.
>>
>>
>>>
>>> Thanks.
>>>
>>>
>>>>> Thanks.
>>>>>
>>>>>
>>>>>>
>>>>>>> +
>>>>>>>
>>>>>>> +
>>>>>>> +#ifndef _UAPI_LINUX_VIRTIO_I2C_H
>>>>>>> +#define _UAPI_LINUX_VIRTIO_I2C_H
>>>>>>> +
>>>>>>> +#include <linux/types.h>
>>>>>>> +#include <linux/virtio_ids.h>
>>>>>>> +#include <linux/virtio_config.h>
>>>>>>> +
>>>>>>> +/**
>>>>>>> + * struct virtio_i2c_hdr - the virtio I2C message header structure
>>>>>>> + * @addr: i2c_msg addr, the slave address
>>>>>>> + * @flags: i2c_msg flags
>>>>>>> + * @len: i2c_msg len
>>>>>>> + */
>>>>>>> +struct virtio_i2c_hdr {
>>>>>>> +    __le16 addr;
>>>>>>> +    __le16 flags;
>>>>>>> +    __le16 len;
>>>>>>> +};
>>>>>>
>>>>>>
>>>>>> I'm afraid this is not complete. E.g the status is missed.
>>>>>>
>>>>>> I suspect what virtio-scsi use is better. Which split the in from
>>>>>> the out instead of reusing the same buffer. And it can ease the
>>>>>> uAPI header export.
>>>>>>
>>>>>> Thanks
>>>>>>
>>>>>>
>>>>>
>>>>> I think following definition in uAPI for the status is enough.
>>>>> There is no need to provide a "u8" status in the structure.
>>>>>
>>>>> /* The final status written by the device */
>>>>> #define VIRTIO_I2C_MSG_OK    0
>>>>> #define VIRTIO_I2C_MSG_ERR    1
>>>>>
>>>>> You can see an example in virtio_blk.
>>>>>
>>>>> In the spec:
>>>>>
>>>>> struct virtio_blk_req {
>>>>> le32 type;
>>>>> le32 reserved;
>>>>> le64 sector;
>>>>> u8 data[];
>>>>> u8 status;
>>>>> };
>>>>>
>>>>> In virtio_blk.h, there is only following definitions.
>>>>>
>>>>> #define VIRTIO_BLK_S_OK        0
>>>>> #define VIRTIO_BLK_S_IOERR    1
>>>>> #define VIRTIO_BLK_S_UNSUPP    2
>>>>>
>>>>
>>>> virtio-blk is a bad example, it's just too late to fix. For any new
>>>> introduced uAPI it should be a complete one.
>>>>
>>>> Thanks
>>>>
>>> I checked a relatively new device "virtio_fs".
>>> I found following definition in spec but not in uAPI also.
>>>
>>> struct virtio_fs_req {
>>> // Device -readable part
>>> struct fuse_in_header in;
>>> u8 datain[];
>>> // Device -writable part
>>> struct fuse_out_header out;
>>> u8 dataout[];
>>> };
>>>
>>> So is this also a bad example which has not been fixed yet.
>>
>>
>> Cc Stefan for the answer.
>>
>>
>>> Or what's your mean about "complete" here ? Is there any definition
>>> about "complete uAPI" ?
>>
>>
>> My understanding it should contain all the fields defined in the
>> virtio spec.
>>
>> Thanks
>>
> OK. I noticed this isn't strictly implemented in the current virtio
> codes.
> I'm not sure if this is already a consensus. I will follow it if this
> is the opinion of the majority.


Please do that, this forces us to maintain uABI compatibility which is
what Linux try to maintain for ever.

Thanks


>
> Thanks.
>
>

\
 
 \ /
  Last update: 2020-10-15 09:07    [W:0.099 / U:0.320 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site