Run the installer as follows:

    # sh NVIDIA-Linux-x86_64-1.0-8776-pkg1.run --extract-only

This will create the directory NVIDIA-Linux-x86_64-1.0-8776-pkg1, containing the uncompressed contents of the .run file.

The source files to the kernel interface layer are in the usr/src/nv directory of the extracted .run file. To get to these sources, run:

    # sh NVIDIA-Linux-x86-1.0-6629-pkg1.run --extract-only
    # cd NVIDIA-Linux-x86-1.0-6629-pkg1/usr/src/nv/

Depending on the target system's configuration, the NVIDIA device files used to be created in one of three different ways:

With current NVIDIA driver releases, device files are created or modified by the X driver when the X server is started.

By default, the NVIDIA driver will attempt to create device files with the following attributes:

      UID:  0     - 'root'
      GID:  0     - 'root'
      Mode: 0666  - 'rw-rw-rw-'

Existing device files are changed if their attributes don't match these defaults. If you want the NVIDIA driver to create the device files with different attributes, you can specify them with the "NVreg_DeviceFileUID" (user), "NVreg_DeviceFileGID" (group) and "NVreg_DeviceFileMode" NVIDIA Linux kernel module parameters.

For example, the NVIDIA driver can be instructed to create device files with UID=0 (root), GID=44 (video) and Mode=0660 by passing the following module parameters to the NVIDIA Linux kernel module:

      NVreg_DeviceFileUID=0 
      NVreg_DeviceFileGID=44 
      NVreg_DeviceFileMode=0660

The "NVreg_ModifyDeviceFiles" NVIDIA kernel module parameter will disable dynamic device file management, if set to 0.

The kernel interface layer of the NVIDIA kernel module must be compiled specifically for the configuration and version of your kernel. If you upgrade your kernel, then the simplest solution is to reinstall the driver.

ADVANCED: You can install the NVIDIA kernel module for a non running kernel (for example: in the situation where you just built and installed a new kernel, but have not rebooted yet) with a command line such as this:

    # sh NVIDIA-Linux-x86_64-1.0-8776-pkg1.run --kernel-name='KERNEL_NAME'

Where 'KERNEL_NAME' is what uname -r would report if the target kernel were running.

Not every Linux distribution uses RPM, and NVIDIA wanted a single solution that would work across all Linux distributions. As indicated in the NVIDIA Software License, Linux distributions are welcome to repackage and redistribute the NVIDIA Linux driver in whatever package format they wish.

Yes, because the FTP support in nvidia-installer is based on snarf, it will honor the FTP_PROXY, SNARF_PROXY, and PROXY environment variables.

The pkg# suffix is used to distinguish between .run files containing the same driver, but different sets of precompiled kernel interfaces. If a distribution releases a new kernel after an NVIDIA driver is released, the current NVIDIA driver can be repackaged to include a precompiled kernel interface for that newer kernel (in addition to all the precompiled kernel interfaces that were included in the previous package of the driver).

.run files with the same version number, but different pkg numbers, only differ in what precompiled kernel interfaces are included. Additionally, .run files with higher pkg numbers will contain everything the .run files with lower pkg numbers contain.

This is not necessary. The driver contained within all 1.0-8776 .run files will be identical. There is no need to reinstall.

Yes, the --add-this-kernel .run file option will unpack the .run file, build a precompiled kernel interface for the currently running kernel, and repackage the .run file, appending -custom to the filename. This may be useful, for example. if you administer multiple Linux machines, each running the same kernel.

The nvidia-installer utility is released under the GPL. The latest source code for it is available at: ftp://download.nvidia.com/XFree86/nvidia-installer

One of the most useful tools for diagnosing problems is the X log file in /var/log. Lines that begin with (II) are information, (WW) are warnings, and (EE) are errors. You should make sure that the correct config file (i.e. the config file you are editing) is being used; look for the line that begins with:

    (==) Using config file:

Also make sure that the NVIDIA driver is being used, rather than the “nv” or “vesa” driver. Search for

    (II) LoadModule: "nvidia"

Lines from the driver should begin with:

    (II) NVIDIA(0)

By default, the NVIDIA X driver prints relatively few messages to stderr and the X log file. If you need to troubleshoot, then it may be helpful to enable more verbose output by using the X command line options -verbose and -logverbose, which can be used to set the verbosity level for the stderr and log file messages, respectively. The NVIDIA X driver will output more messages when the verbosity level is at or above 5 (X defaults to verbosity level 1 for stderr and level 3 for the log file). So, to enable verbose messaging from the NVIDIA X driver to both the log file and stderr, you could start X by doing the following

    % startx -- -verbose 5 -logverbose 5

Most systems come with these header files preinstalled. However, NVIDIA provides its own gl.h and glx.h files, which get installed by default as part of driver installation. If you prefer that the NVIDIA-distributed OpenGL header files not be installed, you can pass the --no-opengl-headers option to the NVIDIA-Linux-x86_64-1.0-8776-pkg1.run file during installation.

Yes. Fill out the form at: http://www.nvidia.com/view.asp?FO=driver_update

NVIDIA does not officially support development series kernels. However, all the kernel module source code that interfaces with the Linux kernel is available in the usr/src/nv/ directory of the .run file. NVIDIA encourages members of the Linux community to develop patches to these source files to support development series kernels. A web search will most likely yield several community supported patches.

When measuring any application's memory usage, you must be careful to distinguish between physical system RAM used and virtual mappings of shared resources. For example, most shared libraries exist only once in physical memory but are mapped into multiple processes. This memory should only be counted once when computing total memory usage. In the same way, the video memory on a graphics card or register memory on any device can be mapped into multiple processes. These mappings do not consume normal system RAM.

This has been a frequently discussed topic on XFree86 mailing lists; see, for example:

http://marc.theaimsgroup.com/?l=xfree-xpert&m=96835767116567&w=2

The pmap utility described in the above thread is available here: http://web.hexapodia.org/~adi/pmap.c and is a useful tool in distinguishing between types of memory mappings. For example, while top may indicate that X is using several hundred MB of memory, the last line of output from pmap:

    mapped:   287020 KB writable/private: 9932 KB shared: 264656 KB

reveals that X is really only using roughly 10MB of system RAM (the "writable/private" value).

Note, also, that X must allocate resources on behalf of X clients (the window manager, your web browser, etc); X's memory usage will increase as more clients request resources such as pixmaps, and decrease as you close X applications.

Plain tarballs are no longer available. The .run file is a tarball with a shell script prepended. You can execute the .run file with the --extract-only option to unpack the tarball.

Please visit ftp://download.nvidia.com/XFree86_40/

Security-Enhanced Linux (SELinux) is a set of modifications applied to the Linux kernel and utilities that implement a security policy architecture. When in use it requires that the security type on all shared libraries be set to 'shlib_t'. The installer detects when to set the security type, and sets it on all shared libraries it installs. The option --force-selinux passed to the .run file overrides the detection of when to set the security type.

The installation of GNOME provided in distributions such as Red Hat Enterprise Linux 4 contain several competing interfaces for specifying resolution:

    'System Settings' -> 'Display'

which will update the X configuration file, and

    'Applications' -> 'Preferences' -> 'Screen Resolution'

which will update the per-user screen resolution using the XRandR extension. Your desktop resolution will be limited to the smaller of the two settings. Please be sure to check the setting of each.

The NVIDIA driver does not support the graphics component of the XFree86-DGA (Direct Graphics Access) extension. Applications can use the XDGASelectInput() function to acquire relative pointer motion, but graphics-related functions such as XDGASetMode() and XDGAOpenFramebuffer() will fail.

The graphics component of XFree86-DGA is not supported because it requires a CPU mapping of framebuffer memory. As graphics boards ship with increasing quantities of video memory, the NVIDIA X driver has had to switch to a more dynamic memory mapping scheme that is incompatible with DGA. Furthermore, DGA does not cooperate with other graphics rendering libraries such as Xlib and OpenGL because it accesses GPU resources directly.

It is recommended that applications use OpenGL or Xlib, rather than DGA, for graphics rendering. Using rendering libraries other than DGA will yield better performance and improve interoperability with other X applications.

"Xid" messages indicate that a general GPU error occurred, most often due to the driver misprogramming the GPU or to corruption of the commands sent to the GPU. These messages provide diagnostic information that can be used by NVIDIA to aid in debugging reported problems.

EXT_framebuffer_object is supported on GeForce FX, Quadro FX, and newer GPUs.