ERANGE和EOVERFLOW之间的语义差异是什么？

Question

The errno value ERANGE is documented by POSIX as

Result too large.

and EOVERFLOW is documented as

Value too large to be stored in data type.

What's the semantic difference between these two? Especially considering that ERANGE is used by ISO 9899 (eg in strtol ) with the semantic described for EOVERFLOW . Are these two errno values only distinct for historical reasons?

Please back up your arguments with appropriate sources if possible.

Answer 1

SingleUnix is quite verbose about EOVERFLOW :

Value too large to be stored in data type The user ID or group ID of an IPC or file system object was too large to be stored into appropriate member of the caller-provided structure. This error will only occur on implementations that support a larger range of user ID or group ID values than the declared structure member can support. This usually occurs because the IPC or file system object resides on a remote machine with a larger value of the type uid_t, off_t or gid_t than the local system.

EOVERFLOW seems to be intended to signal a subsystem incompatibility, ie some system returned a larger value than another subsystem can handle.

EOVERFLOW is explained in more detail in the rationale:

Most of the uses of this error code are related to large file support. Typically, these cases occur on systems which support multiple programming environments with different sizes for off_t, but they may also occur in connection with remote file systems.

In addition, when different programming environments have different widths for types such as int and uid_t, several functions may encounter a condition where a value in a particular environment is too wide to be represented. In that case, this error should be raised. For example, suppose the currently running process has 64-bit int, and file descriptor 9223372036854775807 is open and does not have the close-on- exec flag set. If the process then uses execl() to exec a file compiled in a programming environment with 32-bit int, the call to execl() can fail with errno set to [EOVERFLOW]. A similar failure can occur with execl() if any of the user IDs or any of the group IDs to be assigned to the new process image are out of range for the executed file's programming environment.

Note, however, that this condition cannot occur for functions that are explicitly described as always being successful, such as getpid().

Thanks to @rici for the pointer

ERANGE is more like this won't ever fit . strtol() is one example. Another, less clear one: Trying to increment a SYSV semaphore past its configured limit returns ERANGE .

With EOVERFLOW that data is there, it just does not fit into the local data structure(s).

For example, lseek() can return EOVERFLOW . This happens, eg when off_t is only 32bit but the file system can support larger files and you try to seek past the range the OS can handle. Why isn't this ERANGE ? Because the system can handle the operation in principle, it just cannot return it to you in the data type available.

Trying to map more than 2G using mmap() on a 32bit system on Linux returns an EOVERFLOW (other systems return EINVAL ).

Unfortunately, this is not totally consistent. For example, the bluetooth stack returns EOVERFLOW when it finds too many host controllers in the system.

Answer 2

There is a semantic difference:

EOVERFLOW is used for the case where a buffer size os too small and the data transfer requested would overflow the destination buffer, or similar error conditions:

http://man7.org/linux/man-pages/man2/open_by_handle_at.2.html

EOVERFLOW

  The handle->handle_bytes value passed into the call was too small. When this error occurs, handle->handle_bytes is updated to indicate the required size for the handle. 

http://man7.org/linux/man-pages/man2/open.2.html

EOVERFLOW

  pathname refers to a regular file that is too large to be opened. The usual scenario here is that an application compiled on a 32-bit platform without -D_FILE_OFFSET_BITS=64 tried to open a file whose size exceeds (1<<31)-1 bytes; see also O_LARGEFILE above. This is the error specified by POSIX.1; in kernels before 2.6.24, Linux gave the error EFBIG for this case. 

ERANGE is used for values that do not fit in the destination type (C99) and for arguments outside the defined range for specific commands (POSIX)

But it is also used in errors where EOVERFLOW would be more appropriate:

http://man7.org/linux/man-pages/man3/pthread_setname_np.3.html

  The pthread_setname_np() function can fail with the following error: ERANGE The length of the string specified pointed to by name exceeds the allowed limit. The pthread_getname_np() function can fail with the following error: ERANGE The buffer specified by name and len is too small to hold the thread name. 

I guess EOVERFLOW is used for system calls and ERANGE is used in C library functions, standard and not.