Constants

Read data from a file or read a directory.

Look up a name in a directory (no meaning for non-directory objects).

Rewrite existing file data or modify existing directory entries.

Write new data or add directory entries.

Delete an existing directory entry.

Execute a file (no meaning for a directory).

Indicates the file should be opened if it exists, but if the file does not exist, the file should not be created. In this case, the operation should fail with the error NFS4ERR_NOENT.

Indicates the file should be created using the method specified by the CreateMode parameter.

Indicates the file should be created without checking for the existence of a duplicate file in the associated directory.

Indicates the file should be created, but the server should check for the presence of a duplicate file before doing so. If the file exists, the open operation should fail with the error NFS4ERR_EXIST.

Indicates the file should be exclusively created, or created with the condition that no other client should be concurrently creating or opening a file with the same name. If a file with the same name does exist, the operation should fail with the error NFS4ERR_EXIST.

Indicates the client desires read-only access to the file.

Indicates the client desires write-only access to the file.

Indicates the client desires both read and write access to the file.

Indicates no denial of share access to other clients while the file is open.

Indicates denial of read access to other clients while the file is open.

Indicates denial of write access to other clients while the file is open.

Indicates denial of both read and write access to other clients while the file is open.

Indicates a non-blocking read lock.

Indicates a non-blocking write lock.

Indicates a blocking read lock.

Indicates a blocking write lock.

Indicates the application is free to commit any part of the data written and filesystem metadata before returning any results.

Indicates the application must commit all of the data to stable storage and enough filesystem metadata to retrieve the data before returning any results.

Indicates the application must commit the data written plus all filesystem metadata to stable storage before returning any results.

Indicates successful completion of the operation, in that all constituent operations completed without error.

Indicates that permission has been denied. The client does not have the correct permission to perform the requested operation. Note this differs from NFS4ERR_PERM which is constrained to owner or privileged user permission failures.

A locking state of any type has been revoked due to administrative interaction, possibly while the lease is valid, or because a delegation was revoked because of failure to return it, while the lease was valid.

An attribute specified by the client is not supported by the server. This error must not be returned in the GetAttr event.

A UTF-8 string contains a character that is not supported by the server in the context in which it is being used.

A name string in a request consisted of valid UTF-8 characters supported by the server, but the name is not supported by the server as a valid name for current operation. An example might be creating a file or directory named ".." on a server whose file system uses that name for links to parent directories. This error should not be returned due to a normalization issue in a string. When a file system keeps names in a particular normalization form, it is the server's responsibility to do the appropriate normalization, rather than rejecting the name.

This error is returned when an owner or owner_group attribute value cannot be translated to a local representation.

An attempt was made to create an object with an inappropriate type specified.

This error should be returned if the client provides an invalid or unusable cookie in the ReadDir event.

The range specified in the Lock event is not appropriate to the allowable range of offsets for the server. For example, this error results when a server that only supports 32-bit ranges receives a range that cannot be handled by that server.

The server has been able to determine a file locking deadlock condition for a blocking lock request.

For some reason, the application could not process this operation in what was deemed a reasonable time.

An attempt to lock a file is denied. Note this may be a temporary condition.

Either the resource (quota) hard limit has been exceeded for the server, or the client's resource limit on the server has been exceeded.

A file system object of the specified target name already exists. Applicable when creating or renaming a file during the Open or Rename operations.

This error indicates a locking state of any type has been revoked or released due to cancellation of the client's lease, either immediately upon lease expiration, or following a later request for a conflicting lock.

The file system object is too large. The operation would have caused a file system object to grow beyond the server's limit.

The operation is not allowed because a file system object involved in the operation is currently open. Servers may disallow removing or renaming open file system objects.

The server is in its recovery or grace period, which should at least match the lease period of the server. A locking request other than a reclaim could not be granted during that period.

The arguments for this operation are determined to be invalid by the application.

This indicates an unrecoverable I/O error has occurred for the file system.

The current object designates a directory when the current operation does not allow a directory to be accepted as the target of this operation.

A lease being renewed is associated with a file system that has been migrated to a new server.

A READ or WRITE operation was attempted on a file where there was a conflict between the I/O and an existing lock. A conflict may occur if a) there is a share reservation inconsistent with the I/O being done, or b) the range to be read or written intersects an existing mandatory byte-range lock.

An operation was prevented due to the existence of a lock on the target object.

A locking request was attempted that would require the upgrade or downgrade of a lock range already held by the owner when the server does not support atomic upgrade or downgrade of locks.

A lock request is operating on a range that partially overlaps a currently held lock for the current lock-owner and does not precisely match a single such lock, where the server does not support this type of request and thus does not implement POSIX locking semantics.

The request would have caused the server's limit for the number of hard links a file system object may have to be exceeded.

This is returned when the filename in an operation exceeds the server's implementation limit.

This indicates no such file or directory. The file system object referenced by the name specified does not exist.

This indicates no space left on the device. The operation would have caused the server's file system to exceed its limit.

Indicates that the current object is not a directory for an operation in which a directory is required.

An attempt was made to remove a directory that was not empty.

The operation is not supported, either because the operation is an optional one and is not supported by this server or because the operation must not be implemented in the current minor version.

The server cannot guarantee that it has not granted state to another client that may conflict with this client's state. No further reclaims from this client will succeed.

The client attempted a Read, Write, Lock, or other operation not available to the client (e.g., writing to a file opened only for read).

This indicates that the requester is not the owner. The operation was not allowed because the caller is neither a privileged user nor the owner of the target of the operation.

The server cannot guarantee that it has not granted state to another client that may conflict with the requested state. However, this applies only to the state requested in this call; further reclaims may succeed. This result code is only valid for Lock and Open operations.

The reclaim attempted by the client conflicts with a lock already held by another client. Unlike NFS4ERR_RECLAIM_BAD, this can only occur if one of the clients misbehaved. This result code is only valid for Lock and Open operations.

This indicates a read-only file system. A modifying operation was attempted on a read-only file system.

An error that does not map to any of the specific legal NFSv4 protocol error values occurred on the server.

An attempt to open a file with a share reservation has failed due to an existing share conflict.

The current object designates a symbolic link when the current operation does not allow a symbolic link as the target.

This error is used where an operation returns a variable amount of data, with a limit specified by the client. Where the data returned cannot be fitted within the limit specified by the client, this error results.

This indicates an attempt to perform an operation, such as linking, has inappropriately crossed a boundary (e.g., across a file system boundary).