Keef, I need to see a copy of a header on your system:
/usr/include/dirent.h....I'm pretty sure there is a mis-match between that header and the version used when glibc was compiled

Just in case you're gonna waste your own precious time on this, Keef and myself are past this now, all fixed...
It was indeed me being dumb/lazy/cautious... I got my arse in gear, the toolchain is now 'sane'
(ish... its still got old kernel, therefore old kernel headers....)

... But I just built libsentry fine, and went on to compile lots of other stuff, inc FreeCiv, some SDL games, etc...

Gosh, scOttman, I feel so... vindicated! You must have wrongly updatet the kernel headers when you updated the kernel.... For my distro, I call the headers 'libc-headers' instead of kernel-headers so that no one will think they are really related to the running kernel version. No ,wait, I missed this: "(ish... its still got old kernel, therefore old kernel headers....)".

Let me reiterate. When you compile glibc for a new system, you choose a certain version of the includes from the kernel sources. The version of these headers has absolutely no relation to whatever kernel you are running at glibc compile time, nor any relation to the kernel version you plane to release, nor to any upgraded-kernel you might use afterward (well, there a couple of corner cases where this is not *absolutely* true).

The headers used when compiling glibc define how glibc interfaces with the kernel. In order to have a sane system, these same kernel-headers should be used for compiling all software on the system until a new glibc version is created. So, the kernel headers which are present under /usr/include should always be the same for the life of the distro. And note that as soon as you upgrade glibc, you should properly re-compile *every* bit of software on the system. If you have noticed the many GLIBC_VERSION errors on this forum, this is exactly where they come from -mismatching binaries/libs.

This does not mean that you can never upgrade the kernel. The kernel sources do not install their headers under /usr/include -the kernel includes everything it needs under one dir. So, go right ahead and run any kernel version you like. The only time that the headers of the running kernel version matter is when you are compiling out-of-tree kernel modules.

So, make a nice package out of the original headers so they can always be handy and stay the same. Then, do what you like about a running kernel. When you need to compile out-of-tree modules, they are gonna need the full kernel sources *of the running kernel*. Compiling the module will look for the internal kernel headers -usually in the default location /usr/src/linux -otherwise there will be a configuration option which points the build at the correct kernel version.

Read this over and over again until it starts to make sense.

Note that there are other elements to having a truly sane toolchain. The toolchain only consists of three things: glibc, gcc and binutils. Later versions of gcc have external lib dependencie which also should fit and match, but to really understand the basics just consider those three.

Now, a truly sane toolchain is when all three of these components have a 'circular dependency* on each other. That means that *this* glibc was compiled by *this* gcc and linked using *this* binutils. It takes at least two passes to accomplish that. If that sounds like overkill, then you'll never be up to creating your own toolchain. Every major distro -nay, every 'true' distro does this every time the toolchain changes. Why? It is the Right Way (tm) and the only way to ensure that you never see those GLIBC_VERSION errors. Any so-called distro which does not observe these procedures is pure junk and is gonna bring lots of misery to nearly everyone who touches it. You can't simply grab some binaries from just anywhere and start mixing them.

Amigo,
Thanks for the explanation. It is still mostly above my skill level, but I think I get the gist of it. I can understand the need to do several passes when building new tools. There is probably a good analogy somewhere, but I can't think of it yet. If you are using the 'old' tools to build the 'new', the job's not done until you have 'fully-filtered' new tools that can completely replace all the 'old' ones.

When I reboot the system, I get a Gnome system error message basically saying the Gnome Power Management defaults have been corrupted and the
Gnome display is pretty much trashed.

Basically I have to reinstall the system from a recent partition image backup to recover from this since I really don't have a clue as to what acutally got trashed, and I'm not about to install the rpm on my other computers.

Any ideas as to what is going on other that a bad install rpm that's somehow trashing non-related files in ect when it's installed on Fedora and other systems?