use of volatile in iounmap()?
While reviewing some CAN driver I stumbled on iounmap which has following prototype on x86:
extern void iounmap(volatile void __iomem *addr);
I argued that the driver should not use volatile
but then I cannot explain why the argument to
iounmap takes a volatile.
The same goes for many other functions in
the io*.h headers.
Grepping the other archs they mostly follow
same pattern.
Can anyone explain the rational for volatile in this case.
Thanks,
Sam
Quoted 9 lines · Sam Ravnborg
While reviewing some CAN driver I stumbled on iounmap which has following prototype on x86:
extern void
iounmap(volatile void __iomem *addr);I argued that the driver should not use volatile
but then I cannot explain why the argument to
iounmap takes a volatile.
Quoted 8 lines
The same goes for many other functions in
the io*.h headers.Grepping the other archs they mostly follow
same pattern.Can anyone explain the rational for volatile in this case.
Yes. The use of volatile in a function prototype like this means that it is valid to pass a volatile pointer to that function -- in other words, we're telling gcc that we're not going to do anything with the pointer that is invalid for a volatile pointer.
A lot of the "volatile considered harmful" stuff that has been bandied about is explicitly about marking *data* items volatile (it does have its uses, but it's easy to get wrong); Linus has explicitly made the distinction between volatile *data* and volatile *operations*.
-hpa
Quoted 16 lines · H. Peter Anvin
Quoted 15 lines · Sam Ravnborg
While reviewing some CAN driver I stumbled on iounmap which has following prototype on x86:
extern void
iounmap(volatile void __iomem *addr);I argued that the driver should not use volatile
but then I cannot explain why the argument to
iounmap takes a volatile.The same goes for many other functions in
the io*.h headers.Grepping the other archs they mostly follow
same pattern.
Quoted 7 lines
Quoted 2 lines
Can anyone explain the rational for volatile in this case.
Yes. The use of volatile in a function prototype like this means that it is valid to pass a volatile pointer to that function -- in other words, we're telling gcc that we're not going to do anything with the pointer that is invalid for a volatile pointer.
If I understand you correct then it is then not wrong to say that we have the argument volatile to avoid warnings from gcc when we pass a volatile pointer.
And then having the pointer marked volatile put a few restrictions on iounmap().
Quoted 5 lines
A lot of the "volatile considered harmful" stuff that has been bandied about is explicitly about marking *data* items volatile (it does have its uses, but it's easy to get wrong); Linus has explicitly made the distinction between volatile *data* and volatile *operations*.
Yes - but unfortunately the volatile-considered-harmful.txt does many deal with the data part.
Thanks,
Sam
Quoted 9 lines · Sam Ravnborg
Quoted 2 lines
Quoted 1 line
Yes. The use of volatile in a function prototype like this means that it is valid to pass a volatile pointer to that function -- in other words, we're telling gcc that we're not going to do anything with the pointer that is invalid for a volatile pointer.
If I understand you correct then it is then not wrong to say that we have the argument volatile to avoid warnings from gcc when we pass a volatile pointer.
And then having the pointer marked volatile put a few restrictions on
iounmap().
Correct.
Quoted 4 lines
Quoted 1 line
A lot of the "volatile considered harmful" stuff that has been bandied about is explicitly about marking *data* items volatile (it does have its uses, but it's easy to get wrong); Linus has explicitly made the distinction between volatile *data* and volatile *operations*.
Yes - but unfortunately the volatile-considered-harmful.txt does many deal with the data part.
Yes, it does.
-hpa
Quoted 9 lines · Sam Ravnborg
While reviewing some CAN driver I stumbled on iounmap which has following prototype on x86:
extern void
iounmap(volatile void __iomem *addr);I argued that the driver should not use volatile
but then I cannot explain why the argument to
iounmap takes a volatile.
Quoted 7 lines
The same goes for many other functions in
the io*.h headers.Grepping the other archs they mostly follow
same pattern.Can anyone explain the rational for volatile in this case.
"Passing a pointer to volatile is allowed, along with passing pointers to unqualified".