21

Verbatim from Linux' man shmat:

RETURN VALUE

[...] on error (void *) -1 is returned, and errno is set to indicate the cause of the error.

(POSIX tells the same using a slightly different wording.)

Is there any mandatory rule or definition (standard?) that (void *) -1 may not be a valid address?

alk
  • 69,737
  • 10
  • 105
  • 255

3 Answers3

20

0xffffffff is technically a valid address in a 32 bit environment but on most operating systems (Certainly Linux/Windows) will be in the reserved kernel part of the address space. That means that in user mode processes it's safe to use it as a error code since no user mode allocation function would return this as a usable address.

Benj
  • 31,668
  • 17
  • 78
  • 127
  • 3
    Also, virtually all memory managers allocate pointers at some aligned addresses, `(void *)-1` does not observe any possible alignment. – Dmytro Sirenko Nov 09 '12 at 11:17
  • @EarlGray well that's true, but it's still possible for a program to access some offset from the aligned address, so if this was in a valid range it'd be a problem. – Benj Nov 09 '12 at 11:19
15

For simplicity, consider a machine with 16 bits of address space. This machine can address memory from 0 to 65535. In this case (void*) -1 would be the same as 0xffff which is 65535. While technically this address is valid, there are few system that would have anything there that they would allow to be accessed.

The other thing to consider is that almost all POSIX system calls returns -1 on error.

As noted by Benj, it's actually possible to map the address NULL. This can be used for example when you want to see if there is a mapping with a specified shmid, in which case the shmaddr argument is set to NULL and the function return NULL to signify that the shared memory exists.

Some programmer dude
  • 400,186
  • 35
  • 402
  • 621
  • 4
    The question is: why not NULL? Almost all POSIX system calls return NULL if the returned pointer is invalid. – Dmytro Sirenko Nov 09 '12 at 11:27
  • 4
    @EarlGray depending on the Linux distro it's actually possible to map NULL with `mmap`. It's also possible to do it with `VirtualAlloc` on Windows (you have to pass a 1 in as the desired address and let it round down). So NULL can actually be a valid address whereas 0xffffffff can not. – Benj Nov 09 '12 at 11:42
  • @EarlGray It's possible as noted by Benj, and I have updated my answer with a situation when it will return `NULL`. – Some programmer dude Nov 09 '12 at 11:48
  • There are countless systems that have valid, accessible data at address 0xFFFF, most microcontroller systems place their reset vector at that very address. Those systems will often lack virtual memory mapping, so if you try to read that address, you will not get an error, but you will get garbage values. Most often the reset vector is programmed in flash though, so you won't be able to write anything to that address, nothing would happen if you did. – Lundin Nov 09 '12 at 12:53
  • @Lundin The documentation the OP has posted is OS specific, the the question is why does `shmat` behave this way on the OS the docs were written for. It doesn't matter that `0xFFFF` might be valid on other systems. – Benj Nov 09 '12 at 13:50
  • @Lundin Using 16 bit addresses was chosen just because it's easier to write 65535 than 4-billion-whatever the max is on a 32-bit system. :) I've never seen any OS that is fully POSIX compliant on a 16-bit system. – Some programmer dude Nov 09 '12 at 13:56
  • When we say (void*) -1, why is it converted to 65535 for 16bit system? What happens to the -(sign), sir? – Soner from The Ottoman Empire Apr 02 '19 at 06:57
  • @snr Most systems today uses [two's complement](https://en.wikipedia.org/wiki/Two's_complement) to represent negative values. Learn about it, it's crucial information that you need to know. – Some programmer dude Apr 02 '19 at 07:03
14

To answer the question directly, no, there is no mandatory rule, definition, standard, or specification that says (void *) -1 may not be a valid address.

(Of course, no rules, definitions, standards, or specifications about memory addresses are mandatory. I see people walking down the street every day without conforming to the C standard, for example, but I have never seen anybody arrested for it. But, even if we omit the mandatory part, using (void *) -1 as an address is generally not prohibited by common specifications.)

However, it is not necessary for (void *) -1 not to be a valid address in order for shmat to work. It is merely necessary that a successful call to shmat never returns (void *) -1 and that (void *) -1 be supported by the compiler for purposes of testing the return value from shmat. If these two conditions are met, then a program can always distinguish a successful shmat call from an unsuccessful shmat call.

Regarding the second condition, the C standard does not guarantee that (void *) -1 can be used, so POSIX, in specifying that this is an error return from shmat, implicitly requires the C (or other language) implementation to support it. So this is an extension to the language required by POSIX, and it is generally a simple thing for compilers to support.

Regarding the first condition, consider when we might want shmat to return (void *) -1 for a successful call. shmat can be called with a user-requested address or without, in which case the implementation chooses an address. In any normal computer architecture, there are multiple reasons to use addresses that are multiples of various values. For shmat, the most obvious is memory mapping. On architectures with virtual memory, memory is mapped in units of pages, and shmat, when it maps memory for the segment, will map to the start of a page. Any even page size has no multiples that are (void *) -1, since the latter is odd, so shmat never chooses to map a segment to (void *) -1. Even if shmat did not use page size, it would typically use some other alignment, such as 4, 8, or 16 bytes, because providing aligned memory means that structures stored at the start of that memory will be aligned, which results in faster memory access on many processors.

That leaves the case where the user requests (void *) -1 as an address. This would be unusual, and it could work only if the memory segment were a single byte or the memory model allowed wrapping around (or the compiler presented a very strange memory model in which (void *) -1 were not the last byte in the address space). I cannot say for sure whether any POSIX systems support this or not. However, it is clear that this is essentially useless, and nobody has any reason for doing it other than curiosity. Therefore, it is safe and reasonable to rule this case out of shmat, simply saying that is not supported, do not do it.

Eric Postpischil
  • 195,579
  • 13
  • 168
  • 312