diff --git a/common-documentation/mnt-iso9660.go b/common-documentation/mnt-iso9660.go new file mode 100644 index 0000000..081d6d3 --- /dev/null +++ b/common-documentation/mnt-iso9660.go @@ -0,0 +1,96 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var Iso9660DocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "check", + "With check=relaxed, a filename is first converted to lower case before doing the lookup. This is probably only meaningful together with norock and map=normal. (Default: check=strict.)", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("relaxed"), + docvalues.CreateEnumString("strict"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "uid", + "Give all files in the filesystem the indicated user id, possibly overriding the information found in the Rock Ridge extensions. (Default: uid=0.)", + ): docvalues.UIDValue{ + EnforceUsingExisting: true, + }, + docvalues.CreateEnumStringWithDoc( + "gid", + "Give all files in the filesystem the indicated group id, possibly overriding the information found in the Rock Ridge extensions. (Default: gid=0.)", + ): docvalues.GIDValue{ + EnforceUsingExisting: true, + }, + docvalues.CreateEnumStringWithDoc( + "map", + "For non-Rock Ridge volumes, normal name translation maps upper to lower case ASCII, drops a trailing ';1', and converts ';' to '.'. With map=off no name translation is done. See norock. (Default: map=normal.) map=acorn is like map=normal but also apply Acorn extensions if present.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("normal"), + docvalues.CreateEnumString("off"), + docvalues.CreateEnumString("acorn"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "mode", + "For non-Rock Ridge volumes, give all files the indicated mode. (Default: read and execute permission for everybody.) Octal mode values require a leading 0.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "block", + "Set the block size to the indicated value. (Default: block=1024.)", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("512"), + docvalues.CreateEnumString("1024"), + docvalues.CreateEnumString("2048"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "session", + "Select number of session on a multisession CD.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "sbsector", + "Session begins from sector xxx.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "iocharset", + "Character set to use for converting 16 bit Unicode characters on CD to 8 bit characters. The default is iso8859-1.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: AvailableCharsets, + }, + docvalues.CreateEnumStringWithDoc( + "conv", + "This option is obsolete and may fail or being ignored.", + ): docvalues.StringValue{}, +} + +var Iso9660DocumentationEnums = []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "norock", + "Disable the use of Rock Ridge extensions, even if available. Cf. map.", + ), + docvalues.CreateEnumStringWithDoc( + "nojoliet", + "Disable the use of Microsoft Joliet extensions, even if available. Cf. map.", + ), + docvalues.CreateEnumStringWithDoc( + "unhide", + "Also show hidden and associated files. (If the ordinary files and the associated or hidden files have the same filenames, this may make the ordinary files inaccessible.)", + ), + docvalues.CreateEnumStringWithDoc( + "cruft", + "If the high byte of the file length contains other garbage, set this mount option to ignore the high order bits of the file length. This implies that a file cannot be larger than 16 MB.", + ), + docvalues.CreateEnumStringWithDoc( + "utf8", + "Convert 16 bit Unicode characters on CD to UTF-8.", + ), +} diff --git a/common-documentation/mnt-jfs.go b/common-documentation/mnt-jfs.go new file mode 100644 index 0000000..06a1ea4 --- /dev/null +++ b/common-documentation/mnt-jfs.go @@ -0,0 +1,55 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var JfsDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "iocharset", + "Character set to use for converting from Unicode to ASCII. The default is to do no conversion. Use iocharset=utf8 for UTF8 translations. This requires CONFIG_NLS_UTF8 to be set in the kernel .config file.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: AvailableCharsets, + }, + docvalues.CreateEnumStringWithDoc( + "resize", + "Resize the volume to value blocks. JFS only supports growing a volume, not shrinking it. This option is only valid during a remount, when the volume is mounted read-write. The resize keyword with no value will grow the volume to the full size of the partition.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "nointegrity", + "Do not write to the journal. The primary use of this option is to allow for higher performance when restoring a volume from backup media. The integrity of the volume is not guaranteed if the system abnormally ends.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "errors", + "Define the behavior when an error is encountered. (Either ignore errors and just mark the filesystem erroneous and continue, or remount the filesystem read-only, or panic and halt the system.)", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("continue"), + docvalues.CreateEnumString("remount-ro"), + docvalues.CreateEnumString("panic"), + }, + }, +} + +var JfsDocumentationEnums = []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "integrity", + "Default. Commit metadata changes to the journal. Use this option to remount a volume where the nointegrity option was previously specified in order to restore normal behavior.", + ), + docvalues.CreateEnumStringWithDoc( + "noquota", + "These options are accepted but ignored.", + ), + docvalues.CreateEnumStringWithDoc( + "quota", + "These options are accepted but ignored.", + ), + docvalues.CreateEnumStringWithDoc( + "usrquota", + "These options are accepted but ignored.", + ), + docvalues.CreateEnumStringWithDoc( + "grpquota", + "These options are accepted but ignored.", + ), +} diff --git a/common-documentation/mnt-msdos.go b/common-documentation/mnt-msdos.go new file mode 100644 index 0000000..0f834a0 --- /dev/null +++ b/common-documentation/mnt-msdos.go @@ -0,0 +1,183 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var MsdosDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "uid", + "Set the owner and group of all files. (Default: the UID and GID of the current process.)", + ): docvalues.UIDValue{ + EnforceUsingExisting: true, + }, + docvalues.CreateEnumStringWithDoc( + "gid", + "Set the owner and group of all files. (Default: the UID and GID of the current process.)", + ): docvalues.GIDValue{ + EnforceUsingExisting: true, + }, + docvalues.CreateEnumStringWithDoc( + "umask", + "Set the umask (the bitmask of the permissions that are not present). The default is the umask of the current process. The value is given in octal.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "dmask", + "Set the umask applied to directories only. The default is the umask of the current process. The value is given in octal.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "fmask", + "Set the umask applied to regular files only. The default is the umask of the current process. The value is given in octal.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "allow_utime", + "This option controls the permission check of mtime/atime.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "check", + "Three different levels of pickiness can be chosen: relaxed, normal, strict.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("relaxed"), + docvalues.CreateEnumString("normal"), + docvalues.CreateEnumString("strict"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "codepage", + "Sets the codepage for converting to shortname characters on FAT and VFAT filesystems. By default, codepage 437 is used.", + ): docvalues.NumberValue{Min: &zero}, + docvalues.CreateEnumStringWithDoc( + // TODO: Show warning in analyzevalue when used + "conv", + "This option is obsolete and may fail or be ignored.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "cvf_format", + "Forces the driver to use the CVF (Compressed Volume File) module cvf_module instead of auto-detection. If the kernel supports kmod, the cvf_format=xxx option also controls on-demand CVF module loading. This option is obsolete.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "cvf_option", + "Option passed to the CVF module. This option is obsolete.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "errors", + "Specify FAT behavior on critical errors: panic, continue without doing anything, or remount the partition in read-only mode (default behavior).", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "panic", + "Causes the kernel to panic on errors.", + ), + docvalues.CreateEnumStringWithDoc( + "continue", + "Continues without doing anything.", + ), + docvalues.CreateEnumStringWithDoc( + "remount", + "Remounts the partition in read-only mode.", + ), + }, + }, + docvalues.CreateEnumStringWithDoc( + "fat", + "Specify a 12, 16 or 32 bit fat. This overrides the automatic FAT type detection routine. Use with caution!", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("12"), + docvalues.CreateEnumString("16"), + docvalues.CreateEnumString("32"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "iocharset", + "Character set to use for converting between 8 bit characters and 16 bit Unicode characters. The default is iso8859-1. Long filenames are stored on disk in Unicode format.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: AvailableCharsets, + }, + docvalues.CreateEnumStringWithDoc( + "nfs", + `Enable this only if you want to export the FAT filesystem over NFS. + To maintain backward compatibility, -o nfs is also accepted, defaulting to stale_rw`, + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "stale_rw", + "This option maintains an index (cache) of directory inodes which is used by the nfs-related code to improve look-ups. Full file operations (read/write) over NFS are supported but with cache eviction at NFS server, this could result in spurious ESTALE errors.", + ), + docvalues.CreateEnumStringWithDoc( + "nostale_ro", + "This option bases the inode number and file handle on the on-disk location of a file in the FAT directory entry. This ensures that ESTALE will not be returned after a file is evicted from the inode cache. However, it means that operations such as rename, create and unlink could cause file handles that previously pointed at one file to point at a different file, potentially causing data corruption. For this reason, this option also mounts the filesystem readonly.", + ), + }, + }, + docvalues.CreateEnumStringWithDoc( + "tz", + "This option disables the conversion of timestamps between local time (as used by Windows on FAT) and UTC (which Linux uses internally). This is particularly useful when mounting devices (like digital cameras) that are set to UTC in order to avoid the pitfalls of local time.", + // TODO: Add enum for timezones + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "time_offset", + "Set offset for conversion of timestamps from local time used by FAT to UTC. I.e., minutes will be subtracted from each timestamp to convert it to UTC used internally by Linux. This is useful when the time zone set in the kernel via settimeofday(2) is not the time zone used by the filesystem. Note that this option still does not provide correct time stamps in all cases in presence of DST - time stamps in a different DST setting will be off by one hour.", + ): docvalues.NumberValue{}, + docvalues.CreateEnumStringWithDoc( + "dotsOK", + "Various misguided attempts to force Unix or DOS conventions onto a FAT filesystem.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("yes"), + docvalues.CreateEnumString("no"), + }, + }, +} + +var MsdosDocumentationEnums = []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "debug", + "Turn on the debug flag. A version string and a list of filesystem parameters will be printed (these data are also printed if the parameters appear to be inconsistent).", + ), + docvalues.CreateEnumStringWithDoc( + "discard", + "If set, causes discard/TRIM commands to be issued to the block device when blocks are freed. This is useful for SSD devices and sparse/thinly-provisioned LUNs.", + ), + docvalues.CreateEnumStringWithDoc( + "dos1xfloppy", + "If set, use a fallback default BIOS Parameter Block configuration, determined by backing device size. These static parameters match defaults assumed by DOS 1.x for 160 kiB, 180 kiB, 320 kiB, and 360 kiB floppies and floppy images.", + ), + docvalues.CreateEnumStringWithDoc( + "quiet", + "Turn on the quiet flag. Attempts to chown or chmod files do not return errors, although they fail. Use with caution!", + ), + docvalues.CreateEnumStringWithDoc( + "rodir", + "FAT has the ATTR_RO (read-only) attribute. On Windows, the ATTR_RO of the directory will just be ignored, and is used only by applications as a flag (e.g. it’s set for the customized folder). If you want to use ATTR_RO as read-only flag even for the directory, set this option.", + ), + docvalues.CreateEnumStringWithDoc( + "showexec", + "If set, the execute permission bits of the file will be allowed only if the extension part of the name is .EXE, .COM, or .BAT. Not set by default.", + ), + docvalues.CreateEnumStringWithDoc( + "sys_immutable", + "If set, ATTR_SYS attribute on FAT is handled as IMMUTABLE flag on Linux. Not set by default.", + ), + docvalues.CreateEnumStringWithDoc( + "flush", + "If set, the filesystem will try to flush to disk more early than normal. Not set by default.", + ), + docvalues.CreateEnumStringWithDoc( + "usefree", + "Use the \"free clusters\" value stored on FSINFO. It’ll be used to determine number of free clusters without scanning disk. But it’s not used by default, because recent Windows don’t update it correctly in some case. If you are sure the \"free clusters\" on FSINFO is correct, by this option you can avoid scanning disk.", + ), + docvalues.CreateEnumStringWithDoc( + "dots", + "Various misguided attempts to force Unix or DOS conventions onto a FAT filesystem.", + ), + docvalues.CreateEnumStringWithDoc( + "nodots", + "Various misguided attempts to force Unix or DOS conventions onto a FAT filesystem.", + ), +} diff --git a/common-documentation/mnt-ncpfs.go b/common-documentation/mnt-ncpfs.go new file mode 100644 index 0000000..193d06c --- /dev/null +++ b/common-documentation/mnt-ncpfs.go @@ -0,0 +1,7 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var NcpfsDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{} + +var NcpfsDocumentationEnums = []docvalues.EnumString{} diff --git a/common-documentation/mnt-ntfs.go b/common-documentation/mnt-ntfs.go new file mode 100644 index 0000000..e057abb --- /dev/null +++ b/common-documentation/mnt-ntfs.go @@ -0,0 +1,57 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var NtfsDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "iocharset", + "Character set to use when returning file names. Unlike VFAT, NTFS suppresses names that contain nonconvertible characters. Deprecated.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "nls", + "New name for the option earlier called iocharset.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "utf8", + "Use UTF-8 for converting file names.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "uni_xlate", + "For 0 (or 'no' or 'false'), do not use escape sequences for unknown Unicode characters. For 1 (or 'yes' or 'true') or 2, use vfat-style 4-byte escape sequences starting with ':'. Here 2 gives a little-endian encoding and 1 a byteswapped bigendian encoding.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("0"), + docvalues.CreateEnumString("1"), + docvalues.CreateEnumString("2"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "posix", + "If enabled (posix=1), the filesystem distinguishes between upper and lower case. The 8.3 alias names are presented as hard links instead of being suppressed. This option is obsolete.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("0"), + docvalues.CreateEnumString("1"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "uid", + "Set the file permission on the filesystem. The umask value is given in octal. By default, the files are owned by root and not readable by somebody else.", + ): docvalues.UIDValue{ + EnforceUsingExisting: true, + }, + docvalues.CreateEnumStringWithDoc( + "gid", + "Set the file permission on the filesystem. The umask value is given in octal. By default, the files are owned by root and not readable by somebody else.", + ): docvalues.GIDValue{ + EnforceUsingExisting: true, + }, + docvalues.CreateEnumStringWithDoc( + "umask", + "Set the file permission on the filesystem. The umask value is given in octal. By default, the files are owned by root and not readable by somebody else.", + ): docvalues.UmaskValue{}, +} + +var NtfsDocumentationEnums = []docvalues.EnumString{} diff --git a/common-documentation/mnt-overlay.go b/common-documentation/mnt-overlay.go new file mode 100644 index 0000000..1044df0 --- /dev/null +++ b/common-documentation/mnt-overlay.go @@ -0,0 +1,120 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var OverlayDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "lowerdir", + "Any filesystem, does not need to be on a writable filesystem.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "upperdir", + "The upperdir is normally on a writable filesystem.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "workdir", + "The workdir needs to be an empty directory on the same filesystem as upperdir.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "redirect_dir", + "If the redirect_dir feature is enabled, then the directory will be copied up (but not the contents). Then the \"{trusted|user}.overlay.redirect\" extended attribute is set to the path of the original location from the root of the overlay. Finally the directory is moved to the new location.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("on"), + docvalues.CreateEnumString("off"), + docvalues.CreateEnumString("follow"), + docvalues.CreateEnumString("nofollow"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "index", + "Inode index. If this feature is disabled and a file with multiple hard links is copied up, then this will \"break\" the link. Changes will not be propagated to other names referring to the same inode.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("on"), + docvalues.CreateEnumString("off"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "uuid", + "Can be used to replace UUID of the underlying filesystem in file handles with null, and effectively disable UUID checks. This can be useful in case the underlying disk is copied and the UUID of this copy is changed. This is only applicable if all lower/upper/work directories are on the same filesystem, otherwise it will fallback to normal behaviour.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("on"), + docvalues.CreateEnumString("off"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "nfs_export", + "When the underlying filesystems supports NFS export and the \"nfs_export\" feature is enabled, an overlay filesystem may be exported to NFS.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("on"), + docvalues.CreateEnumString("off"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "xino", + "The \"xino\" feature composes a unique object identifier from the real object st_ino and an underlying fsid index. The \"xino\" feature uses the high inode number bits for fsid, because the underlying filesystems rarely use the high inode number bits. In case the underlying inode number does overflow into the high xino bits, overlay filesystem will fall back to the non xino behavior for that inode.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("on"), + docvalues.CreateEnumString("off"), + docvalues.CreateEnumString("auto"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "metacopy", + "When metadata only copy up feature is enabled, overlayfs will only copy up metadata (as opposed to whole file), when a metadata specific operation like chown/chmod is performed. Full file will be copied up later when file is opened for WRITE operation.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("on"), + docvalues.CreateEnumString("off"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "volatile", + "Volatile mounts are not guaranteed to survive a crash. It is strongly recommended that volatile mounts are only used if data written to the overlay can be recreated without significant effort.", + ): docvalues.StringValue{}, +} + +var OverlayDocumentationEnums = []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "userxattr", + "Use the \"user.overlay.\" xattr namespace instead of \"trusted.overlay.\". This is useful for unprivileged mounting of overlayfs.", + ), + docvalues.CreateEnumStringWithDoc( + "redirect_dir", + "Redirects are enabled.", + ), + docvalues.CreateEnumStringWithDoc( + "index", + "Inode index. If this feature is disabled and a file with multiple hard links is copied up, then this will \"break\" the link. Changes will not be propagated to other names referring to the same inode.", + ), + docvalues.CreateEnumStringWithDoc( + "uuid", + "Can be used to replace UUID of the underlying filesystem in file handles with null, and effectively disable UUID checks. This can be useful in case the underlying disk is copied and the UUID of this copy is changed. This is only applicable if all lower/upper/work directories are on the same filesystem, otherwise it will fallback to normal behaviour.", + ), + docvalues.CreateEnumStringWithDoc( + "nfs_export", + "When the underlying filesystems supports NFS export and the \"nfs_export\" feature is enabled, an overlay filesystem may be exported to NFS.", + ), + docvalues.CreateEnumStringWithDoc( + "xino", + "The \"xino\" feature composes a unique object identifier from the real object st_ino and an underlying fsid index. The \"xino\" feature uses the high inode number bits for fsid, because the underlying filesystems rarely use the high inode number bits. In case the underlying inode number does overflow into the high xino bits, overlay filesystem will fall back to the non xino behavior for that inode.", + ), + docvalues.CreateEnumStringWithDoc( + "metacopy", + "When metadata only copy up feature is enabled, overlayfs will only copy up metadata (as opposed to whole file), when a metadata specific operation like chown/chmod is performed. Full file will be copied up later when file is opened for WRITE operation.", + ), + docvalues.CreateEnumStringWithDoc( + "volatile", + "Volatile mounts are not guaranteed to survive a crash. It is strongly recommended that volatile mounts are only used if data written to the overlay can be recreated without significant effort.", + ), +} diff --git a/common-documentation/mnt-reiserfs.go b/common-documentation/mnt-reiserfs.go new file mode 100644 index 0000000..1fb9f59 --- /dev/null +++ b/common-documentation/mnt-reiserfs.go @@ -0,0 +1,70 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var ReiserfsDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "conv", + "Instructs version 3.6 reiserfs software to mount a version 3.5 filesystem, using the 3.6 format for newly created objects. This filesystem will no longer be compatible with reiserfs 3.5 tools.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "hash", + "Choose which hash function reiserfs will use to find files within directories.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("rupasov"), + docvalues.CreateEnumString("tea"), + docvalues.CreateEnumString("r5"), + docvalues.CreateEnumString("detect"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "hashed_relocation", + "Tunes the block allocator. This may provide performance improvements in some situations.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "no_unhashed_relocation", + "Tunes the block allocator. This may provide performance improvements in some situations.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "noborder", + "Disable the border allocator algorithm invented by Yury Yu. Rupasov. This may provide performance improvements in some situations.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "nolog", + "Disable journaling. This will provide slight performance improvements in some situations at the cost of losing reiserfs’s fast recovery from crashes. Even with this option turned on, reiserfs still performs all journaling operations, save for actual writes into its journaling area. Implementation of nolog is a work in progress.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "notail", + "By default, reiserfs stores small files and 'file tails' directly into its tree. This confuses some utilities such as lilo(8). This option is used to disable packing of files into the tree.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "replayonly", + "Replay the transactions which are in the journal, but do not actually mount the filesystem. Mainly used by reiserfsck.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "resize", + "A remount option which permits online expansion of reiserfs partitions. Instructs reiserfs to assume that the device has number blocks. This option is designed for use with devices which are under logical volume management (LVM). There is a special resizer utility which can be obtained from ftp://ftp.namesys.com/pub/reiserfsprogs.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "user_xattr", + "Enable Extended User Attributes. See the [attr(1)](https://www.man7.org/linux/man-pages/man1/attr.1.html) manual page.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "acl", + "Enable POSIX Access Control Lists. See the [acl(5)](https://www.man7.org/linux/man-pages/man5/acl.5.html) manual page.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "barrier", + "This disables / enables the use of write barriers in the journaling code. barrier=none disables, barrier=flush enables (default). This also requires an IO stack which can support barriers, and if reiserfs gets an error on a barrier write, it will disable barriers again with a warning. Write barriers enforce proper on-disk ordering of journal commits, making volatile disk write caches safe to use, at some performance penalty. If your disks are battery-backed in one way or another, disabling barriers may safely improve performance.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("none"), + docvalues.CreateEnumString("flush"), + }, + }, +} + +var ReiserfsDocumentationEnums = []docvalues.EnumString{} diff --git a/common-documentation/mnt-ubifs.go b/common-documentation/mnt-ubifs.go new file mode 100644 index 0000000..476099e --- /dev/null +++ b/common-documentation/mnt-ubifs.go @@ -0,0 +1,35 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var UbifsDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "bulk_read", + "Enable bulk-read. VFS read-ahead is disabled because it slows down the filesystem. Bulk-Read is an internal optimization. Some flashes may read faster if the data are read at one go, rather than at several read requests. For example, OneNAND can do \"read-while-load\" if it reads more than one NAND page.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "no_bulk_read", + "Do not bulk-read. This is the default.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "chk_data_crc", + "Check data CRC-32 checksums. This is the default.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "no_chk_data_crc", + "Do not check data CRC-32 checksums. With this option, the filesystem does not check CRC-32 checksum for data, but it does check it for the internal indexing information. This option only affects reading, not writing. CRC-32 is always calculated when writing the data.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "compr", + "Select the default compressor which is used when new files are written. It is still possible to read compressed files if mounted with the none option.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("none"), + docvalues.CreateEnumString("lzo"), + docvalues.CreateEnumString("zlib"), + }, + }, +} + +var UbifsDocumentationEnums = []docvalues.EnumString{} diff --git a/common-documentation/mnt-udf.go b/common-documentation/mnt-udf.go new file mode 100644 index 0000000..3cb4b27 --- /dev/null +++ b/common-documentation/mnt-udf.go @@ -0,0 +1,104 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var UdfDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "uid", + "Make all files in the filesystem belong to the given user. uid=forget can be specified independently of (or usually in addition to) uid= and results in UDF not storing uids to the media. In fact the recorded uid is the 32-bit overflow uid -1 as defined by the UDF standard. The value is given as either which is a valid user name or the corresponding decimal user id, or the special string 'forget'.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "gid", + "Make all files in the filesystem belong to the given group. gid=forget can be specified independently of (or usually in addition to) gid= and results in UDF not storing gids to the media. In fact the recorded gid is the 32-bit overflow gid -1 as defined by the UDF standard. The value is given as either which is a valid group name or the corresponding decimal group id, or the special string 'forget'.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "umask", + "Mask out the given permissions from all inodes read from the filesystem. The value is given in octal.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "mode", + "If mode= is set the permissions of all non-directory inodes read from the filesystem will be set to the given mode. The value is given in octal.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "dmode", + "If dmode= is set the permissions of all directory inodes read from the filesystem will be set to the given dmode. The value is given in octal.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "bs", + "Set the block size. Default value prior to kernel version 2.6.30 was 2048. Since 2.6.30 and prior to 4.11 it was logical device block size with fallback to 2048. Since 4.11 it is logical block size with fallback to any valid block size between logical device block size and 4096.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "iocharset", + "Set the NLS character set. This requires kernel compiled with CONFIG_UDF_NLS option.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: AvailableCharsets, + }, + docvalues.CreateEnumStringWithDoc( + "session", + "Select the session number for multi-session recorded optical media. (default= last session)", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "anchor", + "Override standard anchor location. (default= 256)", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "lastblock", + "Set the last block of the filesystem.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "conv", + "This option is obsolete and may fail or being ignored.", + ): docvalues.StringValue{}, +} + +var UdfDocumentationEnums = []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "unhide", + "Show otherwise hidden files.", + ), + docvalues.CreateEnumStringWithDoc( + "undelete", + "Show deleted files in lists.", + ), + docvalues.CreateEnumStringWithDoc( + "adinicb", + "Embed data in the inode. (default)", + ), + docvalues.CreateEnumStringWithDoc( + "noadinicb", + "Don’t embed data in the inode.", + ), + docvalues.CreateEnumStringWithDoc( + "shortad", + "Use short UDF address descriptors.", + ), + docvalues.CreateEnumStringWithDoc( + "longad", + "Use long UDF address descriptors. (default)", + ), + docvalues.CreateEnumStringWithDoc( + "nostrict", + "Unset strict conformance.", + ), + docvalues.CreateEnumStringWithDoc( + "utf8", + "Set the UTF-8 character set.", + ), + docvalues.CreateEnumStringWithDoc( + "novrs", + "Ignore the Volume Recognition Sequence and attempt to mount anyway.", + ), + docvalues.CreateEnumStringWithDoc( + "session", + "Select the session number for multi-session recorded optical media. (default= last session)", + ), + docvalues.CreateEnumStringWithDoc( + "anchor", + "Override standard anchor location. (default= 256)", + ), + docvalues.CreateEnumStringWithDoc( + "lastblock", + "Set the last block of the filesystem.", + ), +} diff --git a/common-documentation/mnt-ufs.go b/common-documentation/mnt-ufs.go new file mode 100644 index 0000000..43b1ac1 --- /dev/null +++ b/common-documentation/mnt-ufs.go @@ -0,0 +1,95 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var UfsDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "ufstype", + "UFS is a filesystem widely used in different operating systems. The problem are differences among implementations. Features of some implementations are undocumented, so its hard to recognize the type of ufs automatically. That’s why the user must specify the type of ufs by mount option.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("old"), + docvalues.CreateEnumString("44bsd"), + docvalues.CreateEnumString("ufs2"), + docvalues.CreateEnumString("5xbsd"), + docvalues.CreateEnumString("sun"), + docvalues.CreateEnumString("sunx86"), + docvalues.CreateEnumString("hp"), + docvalues.CreateEnumString("nextstep"), + docvalues.CreateEnumString("nextstep-cd"), + docvalues.CreateEnumString("openstep"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "onerror", + "Set behavior on error.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("panic"), + docvalues.CreateEnumString("lock"), + docvalues.CreateEnumString("umount"), + docvalues.CreateEnumString("repair"), + }, + }, +} + +var UfsDocumentationEnums = []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "old", + "Old format of ufs, this is the default, read only. (Don’t forget to give the -r option.)", + ), + docvalues.CreateEnumStringWithDoc( + "44bsd", + "For filesystems created by a BSD-like system (NetBSD, FreeBSD, OpenBSD).", + ), + docvalues.CreateEnumStringWithDoc( + "ufs2", + "Used in FreeBSD 5.x supported as read-write.", + ), + docvalues.CreateEnumStringWithDoc( + "5xbsd", + "Synonym for ufs2.", + ), + docvalues.CreateEnumStringWithDoc( + "sun", + "For filesystems created by SunOS or Solaris on Sparc.", + ), + docvalues.CreateEnumStringWithDoc( + "sunx86", + "For filesystems created by Solaris on x86.", + ), + docvalues.CreateEnumStringWithDoc( + "hp", + "For filesystems created by HP-UX, read-only.", + ), + docvalues.CreateEnumStringWithDoc( + "nextstep", + "For filesystems created by NeXTStep (on NeXT station) (currently read only).", + ), + docvalues.CreateEnumStringWithDoc( + "nextstep-cd", + "For NextStep CDROMs (block_size == 2048), read-only.", + ), + docvalues.CreateEnumStringWithDoc( + "openstep", + "For filesystems created by OpenStep (currently read only). The same filesystem type is also used by macOS.", + ), + docvalues.CreateEnumStringWithDoc( + "panic", + "If an error is encountered, cause a kernel panic.", + ), + docvalues.CreateEnumStringWithDoc( + "lock", + "These mount options don’t do anything at present; when an error is encountered only a console message is printed.", + ), + docvalues.CreateEnumStringWithDoc( + "umount", + "These mount options don’t do anything at present; when an error is encountered only a console message is printed.", + ), + docvalues.CreateEnumStringWithDoc( + "repair", + "These mount options don’t do anything at present; when an error is encountered only a console message is printed.", + ), +} diff --git a/common-documentation/mnt-umsdos.go b/common-documentation/mnt-umsdos.go new file mode 100644 index 0000000..30822e5 --- /dev/null +++ b/common-documentation/mnt-umsdos.go @@ -0,0 +1,180 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var UmsdosDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "uid", + "Set the owner and group of all files. (Default: the UID and GID of the current process.)", + ): docvalues.UIDValue{ + EnforceUsingExisting: true, + }, + docvalues.CreateEnumStringWithDoc( + "gid", + "Set the owner and group of all files. (Default: the UID and GID of the current process.)", + ): docvalues.GIDValue{ + EnforceUsingExisting: true, + }, + docvalues.CreateEnumStringWithDoc( + "umask", + "Set the umask (the bitmask of the permissions that are not present). The default is the umask of the current process. The value is given in octal.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "dmask", + "Set the umask applied to directories only. The default is the umask of the current process. The value is given in octal.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "fmask", + "Set the umask applied to regular files only. The default is the umask of the current process. The value is given in octal.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "allow_utime", + "This option controls the permission check of mtime/atime.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "check", + "Three different levels of pickiness can be chosen: relaxed, normal, strict.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("relaxed"), + docvalues.CreateEnumString("normal"), + docvalues.CreateEnumString("strict"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "codepage", + "Sets the codepage for converting to shortname characters on FAT and VFAT filesystems. By default, codepage 437 is used.", + ): docvalues.NumberValue{Min: &zero}, + docvalues.CreateEnumStringWithDoc( + "conv", + "This option is obsolete and may fail or be ignored.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "cvf_format", + "Forces the driver to use the CVF (Compressed Volume File) module cvf_module instead of auto-detection. If the kernel supports kmod, the cvf_format=xxx option also controls on-demand CVF module loading. This option is obsolete.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "cvf_option", + "Option passed to the CVF module. This option is obsolete.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "errors", + "Specify FAT behavior on critical errors: panic, continue without doing anything, or remount the partition in read-only mode (default behavior).", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "panic", + "Causes the kernel to panic on errors.", + ), + docvalues.CreateEnumStringWithDoc( + "continue", + "Continues without doing anything.", + ), + docvalues.CreateEnumStringWithDoc( + "remount", + "Remounts the partition in read-only mode.", + ), + }, + }, + docvalues.CreateEnumStringWithDoc( + "fat", + "Specify a 12, 16 or 32 bit fat. This overrides the automatic FAT type detection routine. Use with caution!", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("12"), + docvalues.CreateEnumString("16"), + docvalues.CreateEnumString("32"), + }, + }, + docvalues.CreateEnumStringWithDoc( + "iocharset", + "Character set to use for converting between 8 bit characters and 16 bit Unicode characters. The default is iso8859-1. Long filenames are stored on disk in Unicode format.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: AvailableCharsets, + }, + docvalues.CreateEnumStringWithDoc( + "nfs", + "Enable this only if you want to export the FAT filesystem over NFS. To maintain backward compatibility, -o nfs is also accepted, defaulting to stale_rw", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "stale_rw", + "This option maintains an index (cache) of directory inodes which is used by the nfs-related code to improve look-ups. Full file operations (read/write) over NFS are supported but with cache eviction at NFS server, this could result in spurious ESTALE errors.", + ), + docvalues.CreateEnumStringWithDoc( + "nostale_ro", + "This option bases the inode number and file handle on the on-disk location of a file in the FAT directory entry. This ensures that ESTALE will not be returned after a file is evicted from the inode cache. However, it means that operations such as rename, create and unlink could cause file handles that previously pointed at one file to point at a different file, potentially causing data corruption. For this reason, this option also mounts the filesystem readonly.", + ), + }, + }, + docvalues.CreateEnumStringWithDoc( + "tz", + "This option disables the conversion of timestamps between local time (as used by Windows on FAT) and UTC (which Linux uses internally). This is particularly useful when mounting devices (like digital cameras) that are set to UTC in order to avoid the pitfalls of local time.", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "time_offset", + "Set offset for conversion of timestamps from local time used by FAT to UTC. I.e., minutes will be subtracted from each timestamp to convert it to UTC used internally by Linux. This is useful when the time zone set in the kernel via settimeofday(2) is not the time zone used by the filesystem. Note that this option still does not provide correct time stamps in all cases in presence of DST - time stamps in a different DST setting will be off by one hour.", + ): docvalues.NumberValue{}, + docvalues.CreateEnumStringWithDoc( + "dotsOK", + "Various misguided attempts to force Unix or DOS conventions onto a FAT filesystem.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumString("yes"), + docvalues.CreateEnumString("no"), + }, + }, +} + +var UmsdosDocumentationEnums = []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "debug", + "Turn on the debug flag. A version string and a list of filesystem parameters will be printed (these data are also printed if the parameters appear to be inconsistent).", + ), + docvalues.CreateEnumStringWithDoc( + "discard", + "If set, causes discard/TRIM commands to be issued to the block device when blocks are freed. This is useful for SSD devices and sparse/thinly-provisioned LUNs.", + ), + docvalues.CreateEnumStringWithDoc( + "dos1xfloppy", + "If set, use a fallback default BIOS Parameter Block configuration, determined by backing device size. These static parameters match defaults assumed by DOS 1.x for 160 kiB, 180 kiB, 320 kiB, and 360 kiB floppies and floppy images.", + ), + docvalues.CreateEnumStringWithDoc( + "quiet", + "Turn on the quiet flag. Attempts to chown or chmod files do not return errors, although they fail. Use with caution!", + ), + docvalues.CreateEnumStringWithDoc( + "rodir", + "FAT has the ATTR_RO (read-only) attribute. On Windows, the ATTR_RO of the directory will just be ignored, and is used only by applications as a flag (e.g. it’s set for the customized folder). If you want to use ATTR_RO as read-only flag even for the directory, set this option.", + ), + docvalues.CreateEnumStringWithDoc( + "showexec", + "If set, the execute permission bits of the file will be allowed only if the extension part of the name is .EXE, .COM, or .BAT. Not set by default.", + ), + docvalues.CreateEnumStringWithDoc( + "sys_immutable", + "If set, ATTR_SYS attribute on FAT is handled as IMMUTABLE flag on Linux. Not set by default.", + ), + docvalues.CreateEnumStringWithDoc( + "flush", + "If set, the filesystem will try to flush to disk more early than normal. Not set by default.", + ), + docvalues.CreateEnumStringWithDoc( + "usefree", + "Use the \"free clusters\" value stored on FSINFO. It’ll be used to determine number of free clusters without scanning disk. But it’s not used by default, because recent Windows don’t update it correctly in some case. If you are sure the \"free clusters\" on FSINFO is correct, by this option you can avoid scanning disk.", + ), + docvalues.CreateEnumStringWithDoc( + "dots", + "Various misguided attempts to force Unix or DOS conventions onto a FAT filesystem.", + ), + docvalues.CreateEnumStringWithDoc( + "nodots", + "Various misguided attempts to force Unix or DOS conventions onto a FAT filesystem.", + ), +} diff --git a/common-documentation/mnt-vfat.go b/common-documentation/mnt-vfat.go new file mode 100644 index 0000000..0248712 --- /dev/null +++ b/common-documentation/mnt-vfat.go @@ -0,0 +1,170 @@ +package commondocumentation + +import docvalues "config-lsp/doc-values" + +var VfatDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{ + docvalues.CreateEnumStringWithDoc( + "uid", + "Set the owner and group of all files. (Default: the UID and GID of the current process.)", + ): docvalues.UIDValue{ + EnforceUsingExisting: true, + }, + docvalues.CreateEnumStringWithDoc( + "gid", + "Set the owner and group of all files. (Default: the UID and GID of the current process.)", + ): docvalues.GIDValue{ + EnforceUsingExisting: true, + }, + docvalues.CreateEnumStringWithDoc( + "umask", + "Set the umask (the bitmask of the permissions that are not present). The default is the umask of the current process. The value is given in octal.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "dmask", + "Set the umask applied to directories only. The default is the umask of the current process. The value is given in octal.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "fmask", + "Set the umask applied to regular files only. The default is the umask of the current process. The value is given in octal.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "allow_utime", + "This option controls the permission check of mtime/atime.", + ): docvalues.UmaskValue{}, + docvalues.CreateEnumStringWithDoc( + "codepage", + "Sets the codepage for converting to shortname characters on FAT and VFAT filesystems. By default, codepage 437 is used.", + ): docvalues.NumberValue{Min: &zero}, + docvalues.CreateEnumStringWithDoc( + "errors", + "Specify FAT behavior on critical errors: panic, continue without doing anything, or remount the partition in read-only mode (default behavior).", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "panic", + "Causes the kernel to panic on errors.", + ), + docvalues.CreateEnumStringWithDoc( + "continue", + "Continues without doing anything.", + ), + docvalues.CreateEnumStringWithDoc( + "remount", + "Remounts the partition in read-only mode.", + ), + }, + }, + docvalues.CreateEnumStringWithDoc( + "iocharset", + "Character set to use for converting between 8 bit characters and 16 bit Unicode characters. The default is iso8859-1. Long filenames are stored on disk in Unicode format.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: AvailableCharsets, + }, + docvalues.CreateEnumStringWithDoc( + "nfs", + `Enable this only if you want to export the FAT filesystem over NFS. + To maintain backward compatibility, -o nfs is also accepted, defaulting to stale_rw`, + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "stale_rw", + "This option maintains an index (cache) of directory inodes which is used by the nfs-related code to improve look-ups. Full file operations (read/write) over NFS are supported but with cache eviction at NFS server, this could result in spurious ESTALE errors.", + ), + docvalues.CreateEnumStringWithDoc( + "nostale_ro", + "This option bases the inode number and file handle on the on-disk location of a file in the FAT directory entry. This ensures that ESTALE will not be returned after a file is evicted from the inode cache. However, it means that operations such as rename, create and unlink could cause file handles that previously pointed at one file to point at a different file, potentially causing data corruption. For this reason, this option also mounts the filesystem readonly.", + ), + }, + }, + docvalues.CreateEnumStringWithDoc( + "tz", + "This option disables the conversion of timestamps between local time (as used by Windows on FAT) and UTC (which Linux uses internally). This is particularly useful when mounting devices (like digital cameras) that are set to UTC in order to avoid the pitfalls of local time.", + // TODO: Add enum for timezones + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "time_offset", + "Set offset for conversion of timestamps from local time used by FAT to UTC. I.e., minutes will be subtracted from each timestamp to convert it to UTC used internally by Linux. This is useful when the time zone set in the kernel via settimeofday(2) is not the time zone used by the filesystem. Note that this option still does not provide correct time stamps in all cases in presence of DST - time stamps in a different DST setting will be off by one hour.", + ): docvalues.NumberValue{}, + docvalues.CreateEnumStringWithDoc( + "uni_xlate", + "Translate unhandled Unicode characters to special escaped sequences. This lets you backup and restore filenames that are created with any Unicode characters. Without this option, a '?' is used when no translation is possible. The escape character is ':' because it is otherwise invalid on the vfat filesystem. The escape sequence that gets used, where u is the Unicode character, is: ':', (u & 0x3f), ((u>>6) & 0x3f), (u>>12).", + ): docvalues.StringValue{}, + docvalues.CreateEnumStringWithDoc( + "shortname", + "Defines the behavior for creation and display of filenames which fit into 8.3 characters. If a long name for a file exists, it will always be the preferred one for display.", + ): docvalues.EnumValue{ + EnforceValues: true, + Values: []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "lower", + "Force the short name to lower case upon display; store a long name when the short name is not all upper case.", + ), + docvalues.CreateEnumStringWithDoc( + "win95", + "Force the short name to upper case upon display; store a long name when the short name is not all upper case.", + ), + docvalues.CreateEnumStringWithDoc( + "winnt", + "Display the short name as is; store a long name when the short name is not all lower case or all upper case.", + ), + docvalues.CreateEnumStringWithDoc( + "mixed", + "Display the short name as is; store a long name when the short name is not all upper case. This mode is the default since Linux 2.6.32.", + ), + }, + }, + docvalues.CreateEnumStringWithDoc( + "utf8", + "UTF8 is the filesystem safe 8-bit encoding of Unicode that is used by the console. It can be enabled for the filesystem with this option or disabled with utf8=0, utf8=no or utf8=false. If uni_xlate gets set, UTF8 gets disabled.", + ): docvalues.StringValue{}, +} + +var VfatDocumentationEnums = []docvalues.EnumString{ + docvalues.CreateEnumStringWithDoc( + "debug", + "Turn on the debug flag. A version string and a list of filesystem parameters will be printed (these data are also printed if the parameters appear to be inconsistent).", + ), + docvalues.CreateEnumStringWithDoc( + "discard", + "If set, causes discard/TRIM commands to be issued to the block device when blocks are freed. This is useful for SSD devices and sparse/thinly-provisioned LUNs.", + ), + docvalues.CreateEnumStringWithDoc( + "dos1xfloppy", + "If set, use a fallback default BIOS Parameter Block configuration, determined by backing device size. These static parameters match defaults assumed by DOS 1.x for 160 kiB, 180 kiB, 320 kiB, and 360 kiB floppies and floppy images.", + ), + docvalues.CreateEnumStringWithDoc( + "quiet", + "Turn on the quiet flag. Attempts to chown or chmod files do not return errors, although they fail. Use with caution!", + ), + docvalues.CreateEnumStringWithDoc( + "rodir", + "FAT has the ATTR_RO (read-only) attribute. On Windows, the ATTR_RO of the directory will just be ignored, and is used only by applications as a flag (e.g. it’s set for the customized folder). If you want to use ATTR_RO as read-only flag even for the directory, set this option.", + ), + docvalues.CreateEnumStringWithDoc( + "showexec", + "If set, the execute permission bits of the file will be allowed only if the extension part of the name is .EXE, .COM, or .BAT. Not set by default.", + ), + docvalues.CreateEnumStringWithDoc( + "sys_immutable", + "If set, ATTR_SYS attribute on FAT is handled as IMMUTABLE flag on Linux. Not set by default.", + ), + docvalues.CreateEnumStringWithDoc( + "flush", + "If set, the filesystem will try to flush to disk more early than normal. Not set by default.", + ), + docvalues.CreateEnumStringWithDoc( + "usefree", + "Use the \"free clusters\" value stored on FSINFO. It’ll be used to determine number of free clusters without scanning disk. But it’s not used by default, because recent Windows don’t update it correctly in some case. If you are sure the \"free clusters\" on FSINFO is correct, by this option you can avoid scanning disk.", + ), + docvalues.CreateEnumStringWithDoc( + "dots", + "Various misguided attempts to force Unix or DOS conventions onto a FAT filesystem.", + ), + docvalues.CreateEnumStringWithDoc( + "nodots", + "Various misguided attempts to force Unix or DOS conventions onto a FAT filesystem.", + ), +} diff --git a/handlers/fstab/documentation/documentation-mountoptions.go b/handlers/fstab/documentation/documentation-mountoptions.go index c595ca6..45e186e 100644 --- a/handlers/fstab/documentation/documentation-mountoptions.go +++ b/handlers/fstab/documentation/documentation-mountoptions.go @@ -285,4 +285,52 @@ var MountOptionsMapField = map[string]docvalues.Value{ commondocumentation.HpfsDocumentationEnums, commondocumentation.HpfsDocumentationAssignable, ), + "iso9660": createMountOptionField( + commondocumentation.Iso9660DocumentationEnums, + commondocumentation.Iso9660DocumentationAssignable, + ), + "jfs": createMountOptionField( + commondocumentation.JfsDocumentationEnums, + commondocumentation.JfsDocumentationAssignable, + ), + "msdos": createMountOptionField( + commondocumentation.MsdosDocumentationEnums, + commondocumentation.MsdosDocumentationAssignable, + ), + "ncpfs": createMountOptionField( + commondocumentation.NcpfsDocumentationEnums, + commondocumentation.NcpfsDocumentationAssignable, + ), + "ntfs": createMountOptionField( + commondocumentation.NtfsDocumentationEnums, + commondocumentation.NtfsDocumentationAssignable, + ), + "overlay": createMountOptionField( + commondocumentation.OverlayDocumentationEnums, + commondocumentation.OverlayDocumentationAssignable, + ), + "reiserfs": createMountOptionField( + commondocumentation.ReiserfsDocumentationEnums, + commondocumentation.ReiserfsDocumentationAssignable, + ), + "ubifs": createMountOptionField( + commondocumentation.UbifsDocumentationEnums, + commondocumentation.UbifsDocumentationAssignable, + ), + "udf": createMountOptionField( + commondocumentation.UdfDocumentationEnums, + commondocumentation.UdfDocumentationAssignable, + ), + "ufs": createMountOptionField( + commondocumentation.UfsDocumentationEnums, + commondocumentation.UfsDocumentationAssignable, + ), + "umsdos": createMountOptionField( + commondocumentation.UmsdosDocumentationEnums, + commondocumentation.UmsdosDocumentationAssignable, + ), + "vfat": createMountOptionField( + commondocumentation.VfatDocumentationEnums, + commondocumentation.VfatDocumentationAssignable, + ), }