| Message ID | 1492164934-988-17-git-send-email-eric.auger@redhat.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On Fri, Apr 14, 2017 at 3:45 PM, Eric Auger <eric.auger@redhat.com> wrote: > Add a generic lookup_table() helper whose role consists in > scanning a contiguous table located in guest RAM and applying > a callback on each entry. Entries can be handled as linked lists > since the callback may return an offset to the next entry and > also tell that an entry is the last one. > > Helper functions also are added to compute the device/event ID > offset to the next DTE/ITE. > > compute_next_devid_offset, compute_next_eventid_offset and > lookup_table will become static in subsequent patches > > Signed-off-by: Eric Auger <eric.auger@redhat.com> Tested-by: Prakash, Brahmajyosyula <Brahmajyosyula.Prakash@cavium.com>
On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: > Add a generic lookup_table() helper whose role consists in > scanning a contiguous table located in guest RAM and applying > a callback on each entry. Entries can be handled as linked lists > since the callback may return an offset to the next entry and > also tell that an entry is the last one. > > Helper functions also are added to compute the device/event ID > offset to the next DTE/ITE. > > compute_next_devid_offset, compute_next_eventid_offset and > lookup_table will become static in subsequent patches > > Signed-off-by: Eric Auger <eric.auger@redhat.com> > > --- > v4 -> v5: > - use kvm_read_guest > > v3 -> v4: > - remove static to avoid compilation warning > - correct size computation in looup_table() > - defines now encode the number of bits used for devid and eventid offsets > - use BIT() - 1 to encode the max offets > --- > virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 93 insertions(+) > > diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c > index 56c5123..c22b35d 100644 > --- a/virt/kvm/arm/vgic/vgic-its.c > +++ b/virt/kvm/arm/vgic/vgic-its.c > @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, > > #define VITS_TYPER_IDBITS 16 > #define VITS_TYPER_DEVBITS 16 > +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) > +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) > > /* > * Finds and returns a collection in the ITS collection table. > @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, > return ret; > } > > +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) > +{ > + struct list_head *e = &dev->dev_list; > + struct its_device *next; > + u32 next_offset; > + > + if (e->next == h) > + return 0; > + next = list_entry(e->next, struct its_device, dev_list); > + next_offset = next->device_id - dev->device_id; > + > + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); > +} > + > +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) > +{ > + struct list_head *e = &ite->ite_list; > + struct its_ite *next; > + u32 next_offset; > + > + if (e->next == h) > + return 0; > + next = list_entry(e->next, struct its_ite, ite_list); > + next_offset = next->event_id - ite->event_id; > + > + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); > +} > + > +/** > + * entry_fn_t - Callback called on a table entry restore path > + * @its: its handle > + * @id: id of the entry > + * @entry: pointer to the entry > + * @opaque: pointer to an opaque data > + * @next_offset: minimal ID offset to the next entry. 0 if this > + * entry is the last one, 1 if the entry is invalid, >= 1 if an > + * entry's next_offset field was truly decoded > + * > + * Return: < 0 on error, 0 otherwise > + */ > +typedef int (*entry_fn_t)(struct vgic_its *its, u32 id, void *entry, > + void *opaque, u32 *next_offset); > + > +/** > + * lookup_table - scan a contiguous table in guest RAM and applies a function > + * to each entry > + * > + * @its: its handle > + * @base: base gpa of the table > + * @size: size of the table in bytes > + * @esz: entry size in bytes > + * @start_id: first entry's ID I'm a little confused. Why is this not 0? > + * @fn: function to apply on each entry > + * > + * Return: < 0 on error, 1 if last element identified, 0 otherwise How can you scan the entire table and not find the last element? > + */ > +int lookup_table(struct vgic_its *its, gpa_t base, int size, int esz, > + int start_id, entry_fn_t fn, void *opaque) Is this really a lookup? I think this should be called 'scan_its_table'. > +{ > + void *entry = kzalloc(esz, GFP_KERNEL); > + struct kvm *kvm = its->dev->kvm; > + unsigned long len = size; > + u32 id = start_id; why are ids u32 and not just an unsigned long? > + gpa_t gpa = base; > + int ret; > + > + while (len > 0) { > + u32 next_offset; > + size_t byte_offset; > + > + ret = kvm_read_guest(kvm, gpa, entry, esz); > + if (ret) > + goto out; > + > + ret = fn(its, id, entry, opaque, &next_offset); > + if (ret < 0 || (!ret && !next_offset)) > + goto out; > + > + byte_offset = next_offset * esz; > + id += next_offset; > + gpa += byte_offset; > + len -= byte_offset; > + } > + kfree(entry); > + return 0; > + here you can just set 'ret = 0;' > +out: > + kfree(entry); > + return (ret < 0 ? ret : 1); and then here you can do 'return (ret <= 0 ? ret : 1)' but I actually think it's nicer to just write: if (ret <= 0) return ret; return 1; > +} > + > /** > * vgic_its_save_device_tables - Save the device table and all ITT > * into guest RAM > -- > 2.5.5 > Thanks, -Christoffer
Hi, On 27/04/2017 20:06, Christoffer Dall wrote: > On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: >> Add a generic lookup_table() helper whose role consists in >> scanning a contiguous table located in guest RAM and applying >> a callback on each entry. Entries can be handled as linked lists >> since the callback may return an offset to the next entry and >> also tell that an entry is the last one. >> >> Helper functions also are added to compute the device/event ID >> offset to the next DTE/ITE. >> >> compute_next_devid_offset, compute_next_eventid_offset and >> lookup_table will become static in subsequent patches >> >> Signed-off-by: Eric Auger <eric.auger@redhat.com> >> >> --- >> v4 -> v5: >> - use kvm_read_guest >> >> v3 -> v4: >> - remove static to avoid compilation warning >> - correct size computation in looup_table() >> - defines now encode the number of bits used for devid and eventid offsets >> - use BIT() - 1 to encode the max offets >> --- >> virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ >> 1 file changed, 93 insertions(+) >> >> diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c >> index 56c5123..c22b35d 100644 >> --- a/virt/kvm/arm/vgic/vgic-its.c >> +++ b/virt/kvm/arm/vgic/vgic-its.c >> @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, >> >> #define VITS_TYPER_IDBITS 16 >> #define VITS_TYPER_DEVBITS 16 >> +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) >> +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) >> >> /* >> * Finds and returns a collection in the ITS collection table. >> @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, >> return ret; >> } >> >> +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) >> +{ >> + struct list_head *e = &dev->dev_list; >> + struct its_device *next; >> + u32 next_offset; >> + >> + if (e->next == h) >> + return 0; >> + next = list_entry(e->next, struct its_device, dev_list); >> + next_offset = next->device_id - dev->device_id; >> + >> + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); >> +} >> + >> +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) >> +{ >> + struct list_head *e = &ite->ite_list; >> + struct its_ite *next; >> + u32 next_offset; >> + >> + if (e->next == h) >> + return 0; >> + next = list_entry(e->next, struct its_ite, ite_list); >> + next_offset = next->event_id - ite->event_id; >> + >> + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); >> +} >> + >> +/** >> + * entry_fn_t - Callback called on a table entry restore path >> + * @its: its handle >> + * @id: id of the entry >> + * @entry: pointer to the entry >> + * @opaque: pointer to an opaque data >> + * @next_offset: minimal ID offset to the next entry. 0 if this >> + * entry is the last one, 1 if the entry is invalid, >= 1 if an >> + * entry's next_offset field was truly decoded >> + * >> + * Return: < 0 on error, 0 otherwise >> + */ >> +typedef int (*entry_fn_t)(struct vgic_its *its, u32 id, void *entry, >> + void *opaque, u32 *next_offset); >> + >> +/** >> + * lookup_table - scan a contiguous table in guest RAM and applies a function >> + * to each entry >> + * >> + * @its: its handle >> + * @base: base gpa of the table >> + * @size: size of the table in bytes >> + * @esz: entry size in bytes >> + * @start_id: first entry's ID > > I'm a little confused. Why is this not 0? Because this is meant to be called on a second-level table as well (device table). In that case the start ID != 0. > >> + * @fn: function to apply on each entry >> + * >> + * Return: < 0 on error, 1 if last element identified, 0 otherwise > > How can you scan the entire table and not find the last element? This happens on 2d level tables. The last element might be in another 2d level table. > >> + */ >> +int lookup_table(struct vgic_its *its, gpa_t base, int size, int esz, >> + int start_id, entry_fn_t fn, void *opaque) > > Is this really a lookup? I think this should be called > 'scan_its_table'. ok no strong opinion here. > >> +{ >> + void *entry = kzalloc(esz, GFP_KERNEL); >> + struct kvm *kvm = its->dev->kvm; >> + unsigned long len = size; >> + u32 id = start_id; > > why are ids u32 and not just an unsigned long? will change that. > >> + gpa_t gpa = base; >> + int ret; >> + >> + while (len > 0) { >> + u32 next_offset; >> + size_t byte_offset; >> + >> + ret = kvm_read_guest(kvm, gpa, entry, esz); >> + if (ret) >> + goto out; >> + >> + ret = fn(its, id, entry, opaque, &next_offset); >> + if (ret < 0 || (!ret && !next_offset)) >> + goto out; >> + >> + byte_offset = next_offset * esz; >> + id += next_offset; >> + gpa += byte_offset; >> + len -= byte_offset; >> + } >> + kfree(entry); >> + return 0; >> + > > here you can just set 'ret = 0;' > >> +out: >> + kfree(entry); >> + return (ret < 0 ? ret : 1); > > and then here you can do 'return (ret <= 0 ? ret : 1)' > but I actually think it's nicer to just write: > > if (ret <= 0) > return ret; > return 1; OK thanks Eric > >> +} >> + >> /** >> * vgic_its_save_device_tables - Save the device table and all ITT >> * into guest RAM >> -- >> 2.5.5 >> > > Thanks, > -Christoffer >
On Thu, Apr 27, 2017 at 09:24:57PM +0200, Auger Eric wrote: > Hi, > > On 27/04/2017 20:06, Christoffer Dall wrote: > > On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: > >> Add a generic lookup_table() helper whose role consists in > >> scanning a contiguous table located in guest RAM and applying > >> a callback on each entry. Entries can be handled as linked lists > >> since the callback may return an offset to the next entry and > >> also tell that an entry is the last one. > >> > >> Helper functions also are added to compute the device/event ID > >> offset to the next DTE/ITE. > >> > >> compute_next_devid_offset, compute_next_eventid_offset and > >> lookup_table will become static in subsequent patches > >> > >> Signed-off-by: Eric Auger <eric.auger@redhat.com> > >> > >> --- > >> v4 -> v5: > >> - use kvm_read_guest > >> > >> v3 -> v4: > >> - remove static to avoid compilation warning > >> - correct size computation in looup_table() > >> - defines now encode the number of bits used for devid and eventid offsets > >> - use BIT() - 1 to encode the max offets > >> --- > >> virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ > >> 1 file changed, 93 insertions(+) > >> > >> diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c > >> index 56c5123..c22b35d 100644 > >> --- a/virt/kvm/arm/vgic/vgic-its.c > >> +++ b/virt/kvm/arm/vgic/vgic-its.c > >> @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, > >> > >> #define VITS_TYPER_IDBITS 16 > >> #define VITS_TYPER_DEVBITS 16 > >> +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) > >> +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) > >> > >> /* > >> * Finds and returns a collection in the ITS collection table. > >> @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, > >> return ret; > >> } > >> > >> +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) > >> +{ > >> + struct list_head *e = &dev->dev_list; > >> + struct its_device *next; > >> + u32 next_offset; > >> + > >> + if (e->next == h) > >> + return 0; > >> + next = list_entry(e->next, struct its_device, dev_list); > >> + next_offset = next->device_id - dev->device_id; > >> + > >> + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); > >> +} > >> + > >> +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) > >> +{ > >> + struct list_head *e = &ite->ite_list; > >> + struct its_ite *next; > >> + u32 next_offset; > >> + > >> + if (e->next == h) > >> + return 0; > >> + next = list_entry(e->next, struct its_ite, ite_list); > >> + next_offset = next->event_id - ite->event_id; > >> + > >> + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); > >> +} > >> + > >> +/** > >> + * entry_fn_t - Callback called on a table entry restore path > >> + * @its: its handle > >> + * @id: id of the entry > >> + * @entry: pointer to the entry > >> + * @opaque: pointer to an opaque data > >> + * @next_offset: minimal ID offset to the next entry. 0 if this > >> + * entry is the last one, 1 if the entry is invalid, >= 1 if an > >> + * entry's next_offset field was truly decoded > >> + * > >> + * Return: < 0 on error, 0 otherwise > >> + */ > >> +typedef int (*entry_fn_t)(struct vgic_its *its, u32 id, void *entry, > >> + void *opaque, u32 *next_offset); > >> + > >> +/** > >> + * lookup_table - scan a contiguous table in guest RAM and applies a function > >> + * to each entry > >> + * > >> + * @its: its handle > >> + * @base: base gpa of the table > >> + * @size: size of the table in bytes > >> + * @esz: entry size in bytes > >> + * @start_id: first entry's ID > > > > I'm a little confused. Why is this not 0? > Because this is meant to be called on a second-level table as well > (device table). In that case the start ID != 0. Ah, ok, makes sense. You could use the comment to explain that: @start_id: The ID of the first entry in the table (non-zero for second-level tables) > > > >> + * @fn: function to apply on each entry > >> + * > >> + * Return: < 0 on error, 1 if last element identified, 0 otherwise > > > > How can you scan the entire table and not find the last element? > This happens on 2d level tables. The last element might be in another 2d > level table. Ah, I think you should explain this so that the intended use is clear. Thanks, -Christoffer
On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: > Add a generic lookup_table() helper whose role consists in > scanning a contiguous table located in guest RAM and applying > a callback on each entry. Entries can be handled as linked lists > since the callback may return an offset to the next entry and > also tell that an entry is the last one. > > Helper functions also are added to compute the device/event ID > offset to the next DTE/ITE. > > compute_next_devid_offset, compute_next_eventid_offset and > lookup_table will become static in subsequent patches > > Signed-off-by: Eric Auger <eric.auger@redhat.com> > > --- > v4 -> v5: > - use kvm_read_guest > > v3 -> v4: > - remove static to avoid compilation warning > - correct size computation in looup_table() > - defines now encode the number of bits used for devid and eventid offsets > - use BIT() - 1 to encode the max offets > --- > virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 93 insertions(+) > > diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c > index 56c5123..c22b35d 100644 > --- a/virt/kvm/arm/vgic/vgic-its.c > +++ b/virt/kvm/arm/vgic/vgic-its.c > @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, > > #define VITS_TYPER_IDBITS 16 > #define VITS_TYPER_DEVBITS 16 > +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) > +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) > > /* > * Finds and returns a collection in the ITS collection table. > @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, > return ret; > } > > +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) > +{ > + struct list_head *e = &dev->dev_list; > + struct its_device *next; > + u32 next_offset; > + > + if (e->next == h) > + return 0; > + next = list_entry(e->next, struct its_device, dev_list); > + next_offset = next->device_id - dev->device_id; > + > + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); > +} > + > +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) > +{ > + struct list_head *e = &ite->ite_list; > + struct its_ite *next; > + u32 next_offset; > + > + if (e->next == h) > + return 0; > + next = list_entry(e->next, struct its_ite, ite_list); > + next_offset = next->event_id - ite->event_id; > + > + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); > +} > + > +/** > + * entry_fn_t - Callback called on a table entry restore path > + * @its: its handle > + * @id: id of the entry > + * @entry: pointer to the entry > + * @opaque: pointer to an opaque data > + * @next_offset: minimal ID offset to the next entry. 0 if this > + * entry is the last one, 1 if the entry is invalid, >= 1 if an > + * entry's next_offset field was truly decoded > + * > + * Return: < 0 on error, 0 otherwise > + */ > +typedef int (*entry_fn_t)(struct vgic_its *its, u32 id, void *entry, > + void *opaque, u32 *next_offset); Just noticed. All the table entries are 64-bit long at this point, right? So why not make entry a u64 * instead? Could we end up with some endianness mess with using void pointers the way it is now? Thanks, -Christoffer > + > +/** > + * lookup_table - scan a contiguous table in guest RAM and applies a function > + * to each entry > + * > + * @its: its handle > + * @base: base gpa of the table > + * @size: size of the table in bytes > + * @esz: entry size in bytes > + * @start_id: first entry's ID > + * @fn: function to apply on each entry > + * > + * Return: < 0 on error, 1 if last element identified, 0 otherwise > + */ > +int lookup_table(struct vgic_its *its, gpa_t base, int size, int esz, > + int start_id, entry_fn_t fn, void *opaque) > +{ > + void *entry = kzalloc(esz, GFP_KERNEL); > + struct kvm *kvm = its->dev->kvm; > + unsigned long len = size; > + u32 id = start_id; > + gpa_t gpa = base; > + int ret; > + > + while (len > 0) { > + u32 next_offset; > + size_t byte_offset; > + > + ret = kvm_read_guest(kvm, gpa, entry, esz); > + if (ret) > + goto out; > + > + ret = fn(its, id, entry, opaque, &next_offset); > + if (ret < 0 || (!ret && !next_offset)) > + goto out; > + > + byte_offset = next_offset * esz; > + id += next_offset; > + gpa += byte_offset; > + len -= byte_offset; > + } > + kfree(entry); > + return 0; > + > +out: > + kfree(entry); > + return (ret < 0 ? ret : 1); > +} > + > /** > * vgic_its_save_device_tables - Save the device table and all ITT > * into guest RAM > -- > 2.5.5 >
On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: > Add a generic lookup_table() helper whose role consists in > scanning a contiguous table located in guest RAM and applying > a callback on each entry. Entries can be handled as linked lists > since the callback may return an offset to the next entry and > also tell that an entry is the last one. > > Helper functions also are added to compute the device/event ID > offset to the next DTE/ITE. > > compute_next_devid_offset, compute_next_eventid_offset and > lookup_table will become static in subsequent patches > > Signed-off-by: Eric Auger <eric.auger@redhat.com> > > --- > v4 -> v5: > - use kvm_read_guest > > v3 -> v4: > - remove static to avoid compilation warning > - correct size computation in looup_table() > - defines now encode the number of bits used for devid and eventid offsets > - use BIT() - 1 to encode the max offets > --- > virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 93 insertions(+) > > diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c > index 56c5123..c22b35d 100644 > --- a/virt/kvm/arm/vgic/vgic-its.c > +++ b/virt/kvm/arm/vgic/vgic-its.c > @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, > > #define VITS_TYPER_IDBITS 16 > #define VITS_TYPER_DEVBITS 16 > +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) > +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) > > /* > * Finds and returns a collection in the ITS collection table. > @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, > return ret; > } > > +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) > +{ > + struct list_head *e = &dev->dev_list; > + struct its_device *next; > + u32 next_offset; > + > + if (e->next == h) > + return 0; > + next = list_entry(e->next, struct its_device, dev_list); > + next_offset = next->device_id - dev->device_id; > + > + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); > +} > + > +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) > +{ > + struct list_head *e = &ite->ite_list; > + struct its_ite *next; > + u32 next_offset; > + > + if (e->next == h) > + return 0; > + next = list_entry(e->next, struct its_ite, ite_list); > + next_offset = next->event_id - ite->event_id; > + > + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); > +} > + > +/** > + * entry_fn_t - Callback called on a table entry restore path > + * @its: its handle > + * @id: id of the entry > + * @entry: pointer to the entry > + * @opaque: pointer to an opaque data > + * @next_offset: minimal ID offset to the next entry. 0 if this > + * entry is the last one, 1 if the entry is invalid, >= 1 if an eh, also, did you mean -1 if the entry is invalid? Thanks, -Christoffer
On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: > Add a generic lookup_table() helper whose role consists in > scanning a contiguous table located in guest RAM and applying > a callback on each entry. Entries can be handled as linked lists > since the callback may return an offset to the next entry and > also tell that an entry is the last one. > > Helper functions also are added to compute the device/event ID > offset to the next DTE/ITE. > > compute_next_devid_offset, compute_next_eventid_offset and > lookup_table will become static in subsequent patches > > Signed-off-by: Eric Auger <eric.auger@redhat.com> > > --- > v4 -> v5: > - use kvm_read_guest > > v3 -> v4: > - remove static to avoid compilation warning > - correct size computation in looup_table() > - defines now encode the number of bits used for devid and eventid offsets > - use BIT() - 1 to encode the max offets > --- > virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 93 insertions(+) > > diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c > index 56c5123..c22b35d 100644 > --- a/virt/kvm/arm/vgic/vgic-its.c > +++ b/virt/kvm/arm/vgic/vgic-its.c > @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, > > #define VITS_TYPER_IDBITS 16 > #define VITS_TYPER_DEVBITS 16 > +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) > +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) > > /* > * Finds and returns a collection in the ITS collection table. > @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, > return ret; > } > > +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) > +{ > + struct list_head *e = &dev->dev_list; > + struct its_device *next; > + u32 next_offset; > + > + if (e->next == h) > + return 0; > + next = list_entry(e->next, struct its_device, dev_list); > + next_offset = next->device_id - dev->device_id; > + > + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); > +} > + > +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) > +{ > + struct list_head *e = &ite->ite_list; > + struct its_ite *next; > + u32 next_offset; > + > + if (e->next == h) > + return 0; > + next = list_entry(e->next, struct its_ite, ite_list); > + next_offset = next->event_id - ite->event_id; > + > + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); nit: in both of these functions you can avoid the extra e variable and maybe make this slightly more readable by using these two calls instead: list_is_last(&ite->ite_list, h); next = list_next_entry(ite, ite_list); Thanks, -Christoffer
Hi Christoffer, On 30/04/2017 21:35, Christoffer Dall wrote: > On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: >> Add a generic lookup_table() helper whose role consists in >> scanning a contiguous table located in guest RAM and applying >> a callback on each entry. Entries can be handled as linked lists >> since the callback may return an offset to the next entry and >> also tell that an entry is the last one. >> >> Helper functions also are added to compute the device/event ID >> offset to the next DTE/ITE. >> >> compute_next_devid_offset, compute_next_eventid_offset and >> lookup_table will become static in subsequent patches >> >> Signed-off-by: Eric Auger <eric.auger@redhat.com> >> >> --- >> v4 -> v5: >> - use kvm_read_guest >> >> v3 -> v4: >> - remove static to avoid compilation warning >> - correct size computation in looup_table() >> - defines now encode the number of bits used for devid and eventid offsets >> - use BIT() - 1 to encode the max offets >> --- >> virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ >> 1 file changed, 93 insertions(+) >> >> diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c >> index 56c5123..c22b35d 100644 >> --- a/virt/kvm/arm/vgic/vgic-its.c >> +++ b/virt/kvm/arm/vgic/vgic-its.c >> @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, >> >> #define VITS_TYPER_IDBITS 16 >> #define VITS_TYPER_DEVBITS 16 >> +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) >> +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) >> >> /* >> * Finds and returns a collection in the ITS collection table. >> @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, >> return ret; >> } >> >> +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) >> +{ >> + struct list_head *e = &dev->dev_list; >> + struct its_device *next; >> + u32 next_offset; >> + >> + if (e->next == h) >> + return 0; >> + next = list_entry(e->next, struct its_device, dev_list); >> + next_offset = next->device_id - dev->device_id; >> + >> + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); >> +} >> + >> +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) >> +{ >> + struct list_head *e = &ite->ite_list; >> + struct its_ite *next; >> + u32 next_offset; >> + >> + if (e->next == h) >> + return 0; >> + next = list_entry(e->next, struct its_ite, ite_list); >> + next_offset = next->event_id - ite->event_id; >> + >> + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); >> +} >> + >> +/** >> + * entry_fn_t - Callback called on a table entry restore path >> + * @its: its handle >> + * @id: id of the entry >> + * @entry: pointer to the entry >> + * @opaque: pointer to an opaque data >> + * @next_offset: minimal ID offset to the next entry. 0 if this >> + * entry is the last one, 1 if the entry is invalid, >= 1 if an > > eh, also, did you mean -1 if the entry is invalid? no in case the entry is invalid, we tell the caller that it must inspect the next entry, hence the next_offset = +1. Thanks Eric > > Thanks, > -Christoffer >
On Wed, May 03, 2017 at 08:53:36AM +0200, Auger Eric wrote: > Hi Christoffer, > > On 30/04/2017 21:35, Christoffer Dall wrote: > > On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: > >> Add a generic lookup_table() helper whose role consists in > >> scanning a contiguous table located in guest RAM and applying > >> a callback on each entry. Entries can be handled as linked lists > >> since the callback may return an offset to the next entry and > >> also tell that an entry is the last one. > >> > >> Helper functions also are added to compute the device/event ID > >> offset to the next DTE/ITE. > >> > >> compute_next_devid_offset, compute_next_eventid_offset and > >> lookup_table will become static in subsequent patches > >> > >> Signed-off-by: Eric Auger <eric.auger@redhat.com> > >> > >> --- > >> v4 -> v5: > >> - use kvm_read_guest > >> > >> v3 -> v4: > >> - remove static to avoid compilation warning > >> - correct size computation in looup_table() > >> - defines now encode the number of bits used for devid and eventid offsets > >> - use BIT() - 1 to encode the max offets > >> --- > >> virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ > >> 1 file changed, 93 insertions(+) > >> > >> diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c > >> index 56c5123..c22b35d 100644 > >> --- a/virt/kvm/arm/vgic/vgic-its.c > >> +++ b/virt/kvm/arm/vgic/vgic-its.c > >> @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, > >> > >> #define VITS_TYPER_IDBITS 16 > >> #define VITS_TYPER_DEVBITS 16 > >> +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) > >> +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) > >> > >> /* > >> * Finds and returns a collection in the ITS collection table. > >> @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, > >> return ret; > >> } > >> > >> +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) > >> +{ > >> + struct list_head *e = &dev->dev_list; > >> + struct its_device *next; > >> + u32 next_offset; > >> + > >> + if (e->next == h) > >> + return 0; > >> + next = list_entry(e->next, struct its_device, dev_list); > >> + next_offset = next->device_id - dev->device_id; > >> + > >> + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); > >> +} > >> + > >> +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) > >> +{ > >> + struct list_head *e = &ite->ite_list; > >> + struct its_ite *next; > >> + u32 next_offset; > >> + > >> + if (e->next == h) > >> + return 0; > >> + next = list_entry(e->next, struct its_ite, ite_list); > >> + next_offset = next->event_id - ite->event_id; > >> + > >> + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); > >> +} > >> + > >> +/** > >> + * entry_fn_t - Callback called on a table entry restore path > >> + * @its: its handle > >> + * @id: id of the entry > >> + * @entry: pointer to the entry > >> + * @opaque: pointer to an opaque data > >> + * @next_offset: minimal ID offset to the next entry. 0 if this > >> + * entry is the last one, 1 if the entry is invalid, >= 1 if an > > > > eh, also, did you mean -1 if the entry is invalid? > no in case the entry is invalid, we tell the caller that it must inspect > the next entry, hence the next_offset = +1. hmm, but you say aftterwards that >= 1 if an entry's next_offset field was truly decoded, so this is confusing. Perhaps it would make more sense to get rid of the parameter entirely and change the return value to say: Return: < 0 on error, 0 if the entry was the last one, and > 0 to indicate the offset to the next entry that must be processed when scanning a table. Note that we return 1 for an invalid entry, because scanning a table in this case simply requires us looking at the next entry, but we may return >= to 1 if we found a valid entry and decoded the next field in the entry. What do you think? Thanks, -Christoffer
Hi Christoffer, On 03/05/2017 10:01, Christoffer Dall wrote: > On Wed, May 03, 2017 at 08:53:36AM +0200, Auger Eric wrote: >> Hi Christoffer, >> >> On 30/04/2017 21:35, Christoffer Dall wrote: >>> On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: >>>> Add a generic lookup_table() helper whose role consists in >>>> scanning a contiguous table located in guest RAM and applying >>>> a callback on each entry. Entries can be handled as linked lists >>>> since the callback may return an offset to the next entry and >>>> also tell that an entry is the last one. >>>> >>>> Helper functions also are added to compute the device/event ID >>>> offset to the next DTE/ITE. >>>> >>>> compute_next_devid_offset, compute_next_eventid_offset and >>>> lookup_table will become static in subsequent patches >>>> >>>> Signed-off-by: Eric Auger <eric.auger@redhat.com> >>>> >>>> --- >>>> v4 -> v5: >>>> - use kvm_read_guest >>>> >>>> v3 -> v4: >>>> - remove static to avoid compilation warning >>>> - correct size computation in looup_table() >>>> - defines now encode the number of bits used for devid and eventid offsets >>>> - use BIT() - 1 to encode the max offets >>>> --- >>>> virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ >>>> 1 file changed, 93 insertions(+) >>>> >>>> diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c >>>> index 56c5123..c22b35d 100644 >>>> --- a/virt/kvm/arm/vgic/vgic-its.c >>>> +++ b/virt/kvm/arm/vgic/vgic-its.c >>>> @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, >>>> >>>> #define VITS_TYPER_IDBITS 16 >>>> #define VITS_TYPER_DEVBITS 16 >>>> +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) >>>> +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) >>>> >>>> /* >>>> * Finds and returns a collection in the ITS collection table. >>>> @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, >>>> return ret; >>>> } >>>> >>>> +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) >>>> +{ >>>> + struct list_head *e = &dev->dev_list; >>>> + struct its_device *next; >>>> + u32 next_offset; >>>> + >>>> + if (e->next == h) >>>> + return 0; >>>> + next = list_entry(e->next, struct its_device, dev_list); >>>> + next_offset = next->device_id - dev->device_id; >>>> + >>>> + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); >>>> +} >>>> + >>>> +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) >>>> +{ >>>> + struct list_head *e = &ite->ite_list; >>>> + struct its_ite *next; >>>> + u32 next_offset; >>>> + >>>> + if (e->next == h) >>>> + return 0; >>>> + next = list_entry(e->next, struct its_ite, ite_list); >>>> + next_offset = next->event_id - ite->event_id; >>>> + >>>> + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); >>>> +} >>>> + >>>> +/** >>>> + * entry_fn_t - Callback called on a table entry restore path >>>> + * @its: its handle >>>> + * @id: id of the entry >>>> + * @entry: pointer to the entry >>>> + * @opaque: pointer to an opaque data >>>> + * @next_offset: minimal ID offset to the next entry. 0 if this >>>> + * entry is the last one, 1 if the entry is invalid, >= 1 if an >>> >>> eh, also, did you mean -1 if the entry is invalid? >> no in case the entry is invalid, we tell the caller that it must inspect >> the next entry, hence the next_offset = +1. > jjjjj > hmm, but you say aftterwards that >= 1 if an entry's next_offset field > was truly decoded, so this is confusing. Perhaps it would make more > sense to get rid of the parameter entirely and change the return value > to say: > > Return: < 0 on error, 0 if the entry was the last one, and > 0 to > indicate the offset to the next entry that must be processed > when scanning a table. > > Note that we return 1 for an invalid entry, because scanning a table > in this case simply requires us looking at the next entry, but we may > return >= to 1 if we found a valid entry and decoded the next field in > the entry. > > What do you think? Yes I'm going to experiment that change. Thanks Eric > > Thanks, > -Christoffer > > _______________________________________________ > linux-arm-kernel mailing list > linux-arm-kernel@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel >
Hi Christoffer, On 30/04/2017 21:33, Christoffer Dall wrote: > On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: >> Add a generic lookup_table() helper whose role consists in >> scanning a contiguous table located in guest RAM and applying >> a callback on each entry. Entries can be handled as linked lists >> since the callback may return an offset to the next entry and >> also tell that an entry is the last one. >> >> Helper functions also are added to compute the device/event ID >> offset to the next DTE/ITE. >> >> compute_next_devid_offset, compute_next_eventid_offset and >> lookup_table will become static in subsequent patches >> >> Signed-off-by: Eric Auger <eric.auger@redhat.com> >> >> --- >> v4 -> v5: >> - use kvm_read_guest >> >> v3 -> v4: >> - remove static to avoid compilation warning >> - correct size computation in looup_table() >> - defines now encode the number of bits used for devid and eventid offsets >> - use BIT() - 1 to encode the max offets >> --- >> virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ >> 1 file changed, 93 insertions(+) >> >> diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c >> index 56c5123..c22b35d 100644 >> --- a/virt/kvm/arm/vgic/vgic-its.c >> +++ b/virt/kvm/arm/vgic/vgic-its.c >> @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, >> >> #define VITS_TYPER_IDBITS 16 >> #define VITS_TYPER_DEVBITS 16 >> +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) >> +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) >> >> /* >> * Finds and returns a collection in the ITS collection table. >> @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, >> return ret; >> } >> >> +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) >> +{ >> + struct list_head *e = &dev->dev_list; >> + struct its_device *next; >> + u32 next_offset; >> + >> + if (e->next == h) >> + return 0; >> + next = list_entry(e->next, struct its_device, dev_list); >> + next_offset = next->device_id - dev->device_id; >> + >> + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); >> +} >> + >> +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) >> +{ >> + struct list_head *e = &ite->ite_list; >> + struct its_ite *next; >> + u32 next_offset; >> + >> + if (e->next == h) >> + return 0; >> + next = list_entry(e->next, struct its_ite, ite_list); >> + next_offset = next->event_id - ite->event_id; >> + >> + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); >> +} >> + >> +/** >> + * entry_fn_t - Callback called on a table entry restore path >> + * @its: its handle >> + * @id: id of the entry >> + * @entry: pointer to the entry >> + * @opaque: pointer to an opaque data >> + * @next_offset: minimal ID offset to the next entry. 0 if this >> + * entry is the last one, 1 if the entry is invalid, >= 1 if an >> + * entry's next_offset field was truly decoded >> + * >> + * Return: < 0 on error, 0 otherwise >> + */ >> +typedef int (*entry_fn_t)(struct vgic_its *its, u32 id, void *entry, >> + void *opaque, u32 *next_offset); > > Just noticed. All the table entries are 64-bit long at this point, > right? So why not make entry a u64 * instead? Could we end up with > some endianness mess with using void pointers the way it is now? the size of the entry is ABI dependent while this infrastructure is generic. In each of such function we use u64 entry = *(u64 *)addr; and we do a le64_to_cpu(entry). Do you see something wrong? Otherwise I would be tempted to leave as is. Thanks Eric > > Thanks, > -Christoffer > >> + >> +/** >> + * lookup_table - scan a contiguous table in guest RAM and applies a function >> + * to each entry >> + * >> + * @its: its handle >> + * @base: base gpa of the table >> + * @size: size of the table in bytes >> + * @esz: entry size in bytes >> + * @start_id: first entry's ID >> + * @fn: function to apply on each entry >> + * >> + * Return: < 0 on error, 1 if last element identified, 0 otherwise >> + */ >> +int lookup_table(struct vgic_its *its, gpa_t base, int size, int esz, >> + int start_id, entry_fn_t fn, void *opaque) >> +{ >> + void *entry = kzalloc(esz, GFP_KERNEL); >> + struct kvm *kvm = its->dev->kvm; >> + unsigned long len = size; >> + u32 id = start_id; >> + gpa_t gpa = base; >> + int ret; >> + >> + while (len > 0) { >> + u32 next_offset; >> + size_t byte_offset; >> + >> + ret = kvm_read_guest(kvm, gpa, entry, esz); >> + if (ret) >> + goto out; >> + >> + ret = fn(its, id, entry, opaque, &next_offset); >> + if (ret < 0 || (!ret && !next_offset)) >> + goto out; >> + >> + byte_offset = next_offset * esz; >> + id += next_offset; >> + gpa += byte_offset; >> + len -= byte_offset; >> + } >> + kfree(entry); >> + return 0; >> + >> +out: >> + kfree(entry); >> + return (ret < 0 ? ret : 1); >> +} >> + >> /** >> * vgic_its_save_device_tables - Save the device table and all ITT >> * into guest RAM >> -- >> 2.5.5 >>
On Wed, May 03, 2017 at 03:40:34PM +0200, Auger Eric wrote: > Hi Christoffer, > > On 30/04/2017 21:33, Christoffer Dall wrote: > > On Fri, Apr 14, 2017 at 12:15:28PM +0200, Eric Auger wrote: > >> Add a generic lookup_table() helper whose role consists in > >> scanning a contiguous table located in guest RAM and applying > >> a callback on each entry. Entries can be handled as linked lists > >> since the callback may return an offset to the next entry and > >> also tell that an entry is the last one. > >> > >> Helper functions also are added to compute the device/event ID > >> offset to the next DTE/ITE. > >> > >> compute_next_devid_offset, compute_next_eventid_offset and > >> lookup_table will become static in subsequent patches > >> > >> Signed-off-by: Eric Auger <eric.auger@redhat.com> > >> > >> --- > >> v4 -> v5: > >> - use kvm_read_guest > >> > >> v3 -> v4: > >> - remove static to avoid compilation warning > >> - correct size computation in looup_table() > >> - defines now encode the number of bits used for devid and eventid offsets > >> - use BIT() - 1 to encode the max offets > >> --- > >> virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ > >> 1 file changed, 93 insertions(+) > >> > >> diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c > >> index 56c5123..c22b35d 100644 > >> --- a/virt/kvm/arm/vgic/vgic-its.c > >> +++ b/virt/kvm/arm/vgic/vgic-its.c > >> @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, > >> > >> #define VITS_TYPER_IDBITS 16 > >> #define VITS_TYPER_DEVBITS 16 > >> +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) > >> +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) > >> > >> /* > >> * Finds and returns a collection in the ITS collection table. > >> @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, > >> return ret; > >> } > >> > >> +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) > >> +{ > >> + struct list_head *e = &dev->dev_list; > >> + struct its_device *next; > >> + u32 next_offset; > >> + > >> + if (e->next == h) > >> + return 0; > >> + next = list_entry(e->next, struct its_device, dev_list); > >> + next_offset = next->device_id - dev->device_id; > >> + > >> + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); > >> +} > >> + > >> +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) > >> +{ > >> + struct list_head *e = &ite->ite_list; > >> + struct its_ite *next; > >> + u32 next_offset; > >> + > >> + if (e->next == h) > >> + return 0; > >> + next = list_entry(e->next, struct its_ite, ite_list); > >> + next_offset = next->event_id - ite->event_id; > >> + > >> + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); > >> +} > >> + > >> +/** > >> + * entry_fn_t - Callback called on a table entry restore path > >> + * @its: its handle > >> + * @id: id of the entry > >> + * @entry: pointer to the entry > >> + * @opaque: pointer to an opaque data > >> + * @next_offset: minimal ID offset to the next entry. 0 if this > >> + * entry is the last one, 1 if the entry is invalid, >= 1 if an > >> + * entry's next_offset field was truly decoded > >> + * > >> + * Return: < 0 on error, 0 otherwise > >> + */ > >> +typedef int (*entry_fn_t)(struct vgic_its *its, u32 id, void *entry, > >> + void *opaque, u32 *next_offset); > > > > Just noticed. All the table entries are 64-bit long at this point, > > right? So why not make entry a u64 * instead? Could we end up with > > some endianness mess with using void pointers the way it is now? > the size of the entry is ABI dependent while this infrastructure is > generic. Yes, for a single version of the ABI where all the entries are 64-bit. > In each of such function we use > > u64 entry = *(u64 *)addr; > and we do a le64_to_cpu(entry). > > Do you see something wrong? Otherwise I would be tempted to leave as is. > I don't think there's anything wrong with the current version, and you're right, this always points to an ITS data structure which is LE, so there shouldn't be a problem. I always just quiver when I see void pointers cast to a type in the caller and callee. Just leave it for now. Thanks, -Christoffer
diff --git a/virt/kvm/arm/vgic/vgic-its.c b/virt/kvm/arm/vgic/vgic-its.c index 56c5123..c22b35d 100644 --- a/virt/kvm/arm/vgic/vgic-its.c +++ b/virt/kvm/arm/vgic/vgic-its.c @@ -195,6 +195,8 @@ static struct its_ite *find_ite(struct vgic_its *its, u32 device_id, #define VITS_TYPER_IDBITS 16 #define VITS_TYPER_DEVBITS 16 +#define VITS_DTE_MAX_DEVID_OFFSET (BIT(14) - 1) +#define VITS_ITE_MAX_EVENTID_OFFSET (BIT(16) - 1) /* * Finds and returns a collection in the ITS collection table. @@ -1674,6 +1676,97 @@ int vgic_its_attr_regs_access(struct kvm_device *dev, return ret; } +u32 compute_next_devid_offset(struct list_head *h, struct its_device *dev) +{ + struct list_head *e = &dev->dev_list; + struct its_device *next; + u32 next_offset; + + if (e->next == h) + return 0; + next = list_entry(e->next, struct its_device, dev_list); + next_offset = next->device_id - dev->device_id; + + return min_t(u32, next_offset, VITS_DTE_MAX_DEVID_OFFSET); +} + +u32 compute_next_eventid_offset(struct list_head *h, struct its_ite *ite) +{ + struct list_head *e = &ite->ite_list; + struct its_ite *next; + u32 next_offset; + + if (e->next == h) + return 0; + next = list_entry(e->next, struct its_ite, ite_list); + next_offset = next->event_id - ite->event_id; + + return min_t(u32, next_offset, VITS_ITE_MAX_EVENTID_OFFSET); +} + +/** + * entry_fn_t - Callback called on a table entry restore path + * @its: its handle + * @id: id of the entry + * @entry: pointer to the entry + * @opaque: pointer to an opaque data + * @next_offset: minimal ID offset to the next entry. 0 if this + * entry is the last one, 1 if the entry is invalid, >= 1 if an + * entry's next_offset field was truly decoded + * + * Return: < 0 on error, 0 otherwise + */ +typedef int (*entry_fn_t)(struct vgic_its *its, u32 id, void *entry, + void *opaque, u32 *next_offset); + +/** + * lookup_table - scan a contiguous table in guest RAM and applies a function + * to each entry + * + * @its: its handle + * @base: base gpa of the table + * @size: size of the table in bytes + * @esz: entry size in bytes + * @start_id: first entry's ID + * @fn: function to apply on each entry + * + * Return: < 0 on error, 1 if last element identified, 0 otherwise + */ +int lookup_table(struct vgic_its *its, gpa_t base, int size, int esz, + int start_id, entry_fn_t fn, void *opaque) +{ + void *entry = kzalloc(esz, GFP_KERNEL); + struct kvm *kvm = its->dev->kvm; + unsigned long len = size; + u32 id = start_id; + gpa_t gpa = base; + int ret; + + while (len > 0) { + u32 next_offset; + size_t byte_offset; + + ret = kvm_read_guest(kvm, gpa, entry, esz); + if (ret) + goto out; + + ret = fn(its, id, entry, opaque, &next_offset); + if (ret < 0 || (!ret && !next_offset)) + goto out; + + byte_offset = next_offset * esz; + id += next_offset; + gpa += byte_offset; + len -= byte_offset; + } + kfree(entry); + return 0; + +out: + kfree(entry); + return (ret < 0 ? ret : 1); +} + /** * vgic_its_save_device_tables - Save the device table and all ITT * into guest RAM
Add a generic lookup_table() helper whose role consists in scanning a contiguous table located in guest RAM and applying a callback on each entry. Entries can be handled as linked lists since the callback may return an offset to the next entry and also tell that an entry is the last one. Helper functions also are added to compute the device/event ID offset to the next DTE/ITE. compute_next_devid_offset, compute_next_eventid_offset and lookup_table will become static in subsequent patches Signed-off-by: Eric Auger <eric.auger@redhat.com> --- v4 -> v5: - use kvm_read_guest v3 -> v4: - remove static to avoid compilation warning - correct size computation in looup_table() - defines now encode the number of bits used for devid and eventid offsets - use BIT() - 1 to encode the max offets --- virt/kvm/arm/vgic/vgic-its.c | 93 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+)