Discover Top Posts Tagged with #errno

Popular Recent

Also a thank you from me to Oracle for never breaking my "find the `intro(2)` manpage for the latest Solaris version" shell script logic.

That's the closest thing to a stable interface they offer for programmatically finding out what `errno` are defined on Solaris, so any and all stability in that is sincerely appreciated.

#software #c #errnoname #errno

Props to Oracle for fixing the typo in the Solaris `intro(2)` manpage!

It used to say "MGSIZE" instead of "MSGSIZE" for many many releases of Solaris. And they finally found it and fixed it!

That's the kind of little thing that's easy to basically never fix, especially in big or busy companies. So it's nice to see that they got around to it!

It also means I can remove a line compensating for that typo in `gather-errno-names.sh` in `errnoname`.

#software #errnoname #errno #c

errno: good for humans, lousy for encoding actual errors Dave Taht (°) hacks on libc to, amongst other things, nuke errno. Why? "C has errnos. Show me one program that actually checks for and does something correct for every possible errno a function can return, and I’ll buy you lunch. Maybe the space shuttle did, I don’t know. We’ve certainly crashed enough other spacecraft."(°°) Towards that, in *ebusI* everything embeds the error return as part of the return. e.g. mmap returns a negative value with the 10 possible errors encoded into it (there’s a side function that can turn that new value into a errno and look it up). (°) Fighting the good fight against #bufferbloat since...forever (°°) If you want to collect, tell him @dieswaytoofast sent you 😇

#Libc #bufferbloat #Errno #clang

C is not your friend: the errno interface

Some of the library functions in the C standard (and a lot more in POSIX) set errno to report what went wrong. The interface is pretty simple: the return value of the function tells you that there's been an error, and then errno tells you what it was.

And since it's a standard interface and people are used to it, you may be tempted to use it in your own library APIs. After all, it's got a few advantages. You can use it as a sort of poor man's exception scheme by bailing out on errors and letting the caller read errno to see what caused your code to fail. And you get helper functions like strerror() and warn() for free. But resist this temptation! In the end it will be more trouble than it's worth:

First of all, even with 70–150 error codes to choose from, you'll probably have some errors that don't fit nicely into the scheme, and since it's system-defined you can't extend it. That leads to weird decoder-ring interfaces where you reuse, say, EIO, because it's the closest thing to what you meant. And then your caller can't tell whether an errno of EIO means this new thing, or just the result of an internal write() call that failed.

Second, propagating errno properly is actually hard. In code like this, for example:

fd = open(path, O_RDONLY); if (fd < 0) { fprintf(log_fd, "could not open %s\n", path); return -1; }

an error in the call to fprintf() could set errno again, replacing the error you were trying to report. So you end up with a lot of ugly boilerplate scattered around that saves errno, calls a function, and puts errno back the way it was.

Third, errno values aren't portable. On my linux machine, errno 38 is ENOSYS; on a FreeBSD box it's ENOTSOCK; on Solaris, EL2NSYNC. So you can't send them over the network, or save them to a file that might be read on another machine, or log them without converting them to text first.

So instead, consider defining your own error codes, with numeric values that are part of the interface, and with whatever specific meanings you need. And, if you can, return them as the actual return value of the function rather than needing a side-channel like errno:

Return a signed integer where all negative values are error codes.

Return a pointer-width unsigned integer where certain special values are encoded errors. The linux kernel does this internally, where all addresses below 1 page are error codes; you could use the address of a static datastructure, or an architecturally invalid address.

Return a struct with an error code and other values packed together.

If all else fails, return an error code directly and write any other outputs to a caller-supplied pointer.

And when dealing with library functions, get the error out of errno as quickly as possible, before something else clobbers it!

#not your friend #errno