Skip to contentSkip to conversation

use of volatile in iounmap()?

DISCUSSION Sam Ravnborg 3 participants 5 messages Mar 28, 2008

lore
Share & tools
lore
#0 lore raw

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

#1 lore raw
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

#2 lore raw
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

#3 lore raw
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

#4 lore raw
In reply to Sam Ravnborg
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".