Merge pull request #8 from Myzel394/add-filesystem-documentation

Add more documentation for filesystems

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.NumberValue{Min: &zero},
+	docvalues.CreateEnumStringWithDoc(
+		"sbsector",
+		"Session begins from sector xxx.",
+	): docvalues.NumberValue{Min: &zero},
+	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.",
+	),
+}

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(
+		"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(
+		"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.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",
+		"This option is accepted but ignored.",
+	),
+	docvalues.CreateEnumStringWithDoc(
+		"quota",
+		"This option is accepted but ignored.",
+	),
+	docvalues.CreateEnumStringWithDoc(
+		"usrquota",
+		"This option is accepted but ignored.",
+	),
+	docvalues.CreateEnumStringWithDoc(
+		"grpquota",
+		"This option is accepted but ignored.",
+	),
+}

common-documentation/mnt-msdos.go

@@ -0,0 +1,5 @@
+package commondocumentation
+
+var MsdosDocumentationAssignable = FatDocumentationAssignable
+
+var MsdosDocumentationEnums = FatDocumentationEnums

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{}

common-documentation/mnt-ntfs.go

@@ -0,0 +1,61 @@
+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.EnumValue{
+		EnforceValues: true,
+		Values:        AvailableCharsets,
+	},
+	docvalues.CreateEnumStringWithDoc(
+		"nls",
+		"New name for the option earlier called iocharset.",
+	): 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{
+	docvalues.CreateEnumStringWithDoc(
+		"utf8",
+		"Use UTF-8 for converting file names.",
+	),
+}

common-documentation/mnt-overlay.go

@@ -0,0 +1,154 @@
+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.CreateEnumStringWithDoc(
+				"on",
+				"Redirects are enabled.",
+			),
+			docvalues.CreateEnumStringWithDoc(
+				"off",
+				"Redirects are not created and only followed if \"redirect_always_follow\" feature is enabled in the kernel/module config.",
+			),
+			docvalues.CreateEnumStringWithDoc(
+				"follow",
+				"Redirects are not created, but followed.",
+			),
+			docvalues.CreateEnumStringWithDoc(
+				"nofollow",
+				"Redirects are not created and not followed (equivalent to \"redirect_dir=off\" if \"redirect_always_follow\" feature is not 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.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 encoding a file handle from an overlay filesystem object, the following rules apply
+
+   •   For a non-upper object, encode a lower file handle from lower inode
+
+   •   For an indexed object, encode a lower file handle from copy_up origin
+
+   •   For a pure-upper object and for an existing non-indexed upper object, encode an upper file handle from upper inode
+
+The encoded overlay file handle includes
+
+   •   Header including path type information (e.g. lower/upper)
+
+   •   UUID of the underlying filesystem
+
+   •   Underlying filesystem encoding of underlying inode
+
+This encoding format is identical to the encoding format of file handles that are stored in extended attribute "{trusted|user}.overlay.origin". When decoding an overlay file handle, the following steps are followed
+
+   •   Find underlying layer by UUID and path type information.
+
+   •   Decode the underlying filesystem file handle to underlying dentry.
+
+   •   For a lower file handle, lookup the handle in index directory by name.
+
+   •   If a whiteout is found in index, return ESTALE. This represents an overlay object that was deleted after its file handle was encoded.
+
+   •   For a non-directory, instantiate a disconnected overlay dentry from the decoded underlying dentry, the path type and index inode, if found.
+
+   •   For a directory, use the connected underlying decoded dentry, path type and index, to lookup a connected overlay dentry.
+
+Decoding a non-directory file handle may return a disconnected dentry. copy_up of that disconnected dentry will create an upper index entry with no upper alias.
+
+When overlay filesystem has multiple lower layers, a middle layer directory may have a "redirect" to lower directory. Because middle layer "redirects" are not indexed, a lower file handle that was encoded from the "redirect" origin directory, cannot be used to find the middle or upper layer directory. Similarly, a lower file handle that was encoded from a descendant of the "redirect" origin directory, cannot be used to reconstruct a connected overlay path. To mitigate the cases of directories that cannot be decoded from a lower file handle, these directories are copied up on encode and encoded as an upper file handle. On an overlay filesystem with no upper layer this mitigation cannot be used NFS export in this setup requires turning off redirect follow (e.g.
+"redirect_dir=nofollow").
+
+The overlay filesystem does not support non-directory connectable file handles, so exporting with the subtree_check exportfs configuration will cause failures to lookup files over NFS.
+
+When the NFS export feature is enabled, all directory index entries are verified on mount time to check that upper file handles are not stale. This verification may cause significant overhead in some cases.
+
+Note: the mount options index=off,nfs_export=on are conflicting for a read-write mount and will result in an error.`,
+	): 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.
+
+    For a detailed description of the effect of this option please refer to https://docs.kernel.org/filesystems/overlayfs.html`,
+	): 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.
+
+    In other words, this is delayed data copy up operation and data is copied up when there is a need to actually modify data.`,
+	): docvalues.EnumValue{
+		EnforceValues: true,
+		Values: []docvalues.EnumString{
+			docvalues.CreateEnumString("on"),
+			docvalues.CreateEnumString("off"),
+		},
+	},
+}
+
+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(
+		"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.
+
+    The advantage of mounting with the "volatile" option is that all forms of sync calls to the upper filesystem are omitted.
+
+    In order to avoid a giving a false sense of safety, the syncfs (and fsync) semantics of volatile mounts are slightly different than that of the rest of VFS. If any writeback error occurs on the upperdir’s filesystem after a volatile mount takes place, all sync functions will return an error. Once this condition is reached, the filesystem will not recover, and every subsequent sync call will return an error, even if the upperdir has not experience a new error since the last sync call.
+
+    When overlay is mounted with "volatile" option, the directory "$workdir/work/incompat/volatile" is created. During next mount, overlay checks for this directory and refuses to mount if present. This is a strong indicator that user should throw away upper and work directories and create fresh one. In very limited cases where the user knows that the system has not crashed and contents of upperdir are intact, The "volatile" directory can be removed.
+`,
+	),
+}

common-documentation/mnt-reiserfs.go

@@ -0,0 +1,83 @@
+package commondocumentation
+
+import docvalues "config-lsp/doc-values"
+
+var ReiserfsDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{
+	docvalues.CreateEnumStringWithDoc(
+		"hash",
+		"Choose which hash function reiserfs will use to find files within directories.",
+	): docvalues.EnumValue{
+		EnforceValues: true,
+		Values: []docvalues.EnumString{
+			docvalues.CreateEnumStringWithDoc(
+				"rupasov",
+				"A hash invented by Yury Yu. Rupasov. It is fast and preserves locality, mapping lexicographically close file names to close hash values. This option should not be used, as it causes a high probability of hash collisions.",
+			),
+			docvalues.CreateEnumStringWithDoc(
+				"tea",
+				"A Davis-Meyer function implemented by Jeremy Fitzhardinge. It uses hash permuting bits in the name. It gets high randomness and, therefore, low probability of hash collisions at some CPU cost. This may be used if EHASHCOLLISION errors are experienced with the r5 hash.",
+			),
+			docvalues.CreateEnumStringWithDoc(
+				"r5",
+				"A modified version of the rupasov hash. It is used by default and is the best choice unless the filesystem has huge directories and unusual file-name patterns.",
+			),
+			docvalues.CreateEnumStringWithDoc(
+				"detect",
+				"Instructs mount to detect which hash function is in use by examining the filesystem being mounted, and to write this information into the reiserfs superblock. This is only useful on the first mount of an old format filesystem.",
+			),
+		},
+	},
+	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.NumberValue{Min: &zero},
+	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{
+	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.CreateEnumStringWithDoc(
+		"hashed_relocation",
+		"Tunes the block allocator. This may provide performance improvements in some situations.",
+	),
+	docvalues.CreateEnumStringWithDoc(
+		"no_unhashed_relocation",
+		"Tunes the block allocator. This may provide performance improvements in some situations.",
+	),
+	docvalues.CreateEnumStringWithDoc(
+		"noborder",
+		"Disable the border allocator algorithm invented by Yury Yu. Rupasov. This may provide performance improvements in some situations.",
+	),
+	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.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.CreateEnumStringWithDoc(
+		"replayonly",
+		"Replay the transactions which are in the journal, but do not actually mount the filesystem. Mainly used by reiserfsck.",
+	),
+	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.CreateEnumStringWithDoc(
+		"acl",
+		"Enable POSIX Access Control Lists. See the [acl(5)](https://www.man7.org/linux/man-pages/man5/acl.5.html) manual page.",
+	),
+}

common-documentation/mnt-ubifs.go

@@ -0,0 +1,36 @@
+package commondocumentation
+
+import docvalues "config-lsp/doc-values"
+
+var UbifsDocumentationAssignable = map[docvalues.EnumString]docvalues.Value{
+	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{
+	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.CreateEnumStringWithDoc(
+		"no_bulk_read",
+		"Do not bulk-read. This is the default.",
+	),
+	docvalues.CreateEnumStringWithDoc(
+		"chk_data_crc",
+		"Check data CRC-32 checksums. This is the default.",
+	),
+	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.",
+	),
+}

common-documentation/mnt-udf.go

@@ -0,0 +1,92 @@
+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=<user> 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 <user> which is a valid user name or the corresponding decimal user id, or the special string 'forget'.",
+	): docvalues.UIDValue{
+		EnforceUsingExisting: true,
+	},
+	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=<group> 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 <group> which is a valid group name or the corresponding decimal group id, or the special string 'forget'.",
+	): docvalues.GIDValue{
+		EnforceUsingExisting: true,
+	},
+	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.NumberValue{Min: &zero},
+	docvalues.CreateEnumStringWithDoc(
+		"lastblock",
+		"Set the last block of the filesystem.",
+	): docvalues.NumberValue{Min: &zero},
+}
+
+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.",
+	),
+}

common-documentation/mnt-ufs.go

@@ -0,0 +1,137 @@
+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.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",
+				"For filesystems created by a BSD-like system (NetBSD, FreeBSD, OpenBSD).",
+			),
+			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(
+		"onerror",
+		"Set behavior on error.",
+	): docvalues.EnumValue{
+		EnforceValues: true,
+		Values: []docvalues.EnumString{
+			docvalues.CreateEnumStringWithDoc(
+				"panic",
+				"If an error is encountered, cause a kernel panic.",
+			),
+			docvalues.CreateEnumStringWithDoc(
+				"lock",
+				"This mount option doesn’t do anything at present; when an error is encountered only a console message is printed.",
+			),
+			docvalues.CreateEnumStringWithDoc(
+				"umount",
+				"This mount option doesn’t do anything at present; when an error is encountered only a console message is printed.",
+			),
+			docvalues.CreateEnumStringWithDoc(
+				"repair",
+				"This mount option doesn’t do anything at present; when an error is encountered only a console message is printed.",
+			),
+		},
+	},
+}
+
+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.",
+	),
+}

common-documentation/mnt-umsdos.go

@@ -0,0 +1,17 @@
+package commondocumentation
+
+import (
+	docvalues "config-lsp/doc-values"
+	"config-lsp/utils"
+)
+
+var UmsdosDocumentationAssignable = utils.FilterMap(MsdosDocumentationAssignable, func(key docvalues.EnumString, value docvalues.Value) bool {
+	// `dotsOK` is explicitly not supported
+	if key.InsertText == "dotsOK" {
+		return false
+	}
+
+	return true
+})
+
+var UmsdosDocumentationEnums = MsdosDocumentationEnums

common-documentation/mnt-usbfs.go

@@ -0,0 +1,58 @@
+package commondocumentation
+
+import docvalues "config-lsp/doc-values"
+
+var UsbfsDocumentationAssignable = docvalues.MergeKeyEnumAssignmentMaps(FatDocumentationAssignable, map[docvalues.EnumString]docvalues.Value{
+	docvalues.CreateEnumStringWithDoc(
+		"devuid",
+		"Set the owner of the device files in the usbfs filesystem (default: uid=gid=0)",
+	): docvalues.UIDValue{
+		EnforceUsingExisting: true,
+	},
+	docvalues.CreateEnumStringWithDoc(
+		"devgid",
+		"Set the group of the device files in the usbfs filesystem (default: uid=gid=0)",
+	): docvalues.GIDValue{
+		EnforceUsingExisting: true,
+	},
+	docvalues.CreateEnumStringWithDoc(
+		"devmode",
+		"Set the mode of the device files in the usbfs filesystem (default: 0644). The mode is given in octal.",
+	): docvalues.StringValue{},
+
+	docvalues.CreateEnumStringWithDoc(
+		"busuid",
+		"Set the owner of the bus files in the usbfs filesystem (default: uid=gid=0)",
+	): docvalues.UIDValue{
+		EnforceUsingExisting: true,
+	},
+	docvalues.CreateEnumStringWithDoc(
+		"busgid",
+		"Set the group of the bus files in the usbfs filesystem (default: uid=gid=0)",
+	): docvalues.GIDValue{
+		EnforceUsingExisting: true,
+	},
+	docvalues.CreateEnumStringWithDoc(
+		"busmode",
+		"Set the mode of the bus files in the usbfs filesystem (default: 0555). The mode is given in octal.",
+	): docvalues.StringValue{},
+
+	docvalues.CreateEnumStringWithDoc(
+		"listuid",
+		"Set the owner of the usbfs filesystem root directory (default: uid=gid=0)",
+	): docvalues.UIDValue{
+		EnforceUsingExisting: true,
+	},
+	docvalues.CreateEnumStringWithDoc(
+		"listgid",
+		"Set the group of the usbfs filesystem root directory (default: uid=gid=0)",
+	): docvalues.GIDValue{
+		EnforceUsingExisting: true,
+	},
+	docvalues.CreateEnumStringWithDoc(
+		"listmode",
+		"Set the mode of the usbfs filesystem root directory (default: 0555). The mode is given in octal.",
+	): docvalues.StringValue{},
+})
+
+var UsbfsDocumentationEnums = []docvalues.EnumString{}

common-documentation/mnt-vfat.go

@@ -0,0 +1,49 @@
+package commondocumentation
+
+import docvalues "config-lsp/doc-values"
+
+var VfatDocumentationAssignable = docvalues.MergeKeyEnumAssignmentMaps(FatDocumentationAssignable, map[docvalues.EnumString]docvalues.Value{
+	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.",
+			),
+		},
+	},
+})
+
+var VfatDocumentationEnums = append(FatDocumentationEnums, []docvalues.EnumString{
+	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.CreateEnumStringWithDoc(
+		"posix",
+		"Allow two files with names that only differ in case. This option is obsolete.",
+	),
+	docvalues.CreateEnumStringWithDoc(
+		"monumtail",
+		"First try to make a short name without sequence number, before trying name~num.ext.",
+	),
+	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.",
+	),
+}...)

doc-values/value-key-enum-assignment.go

@@ -114,6 +114,7 @@ func (v KeyEnumAssignmentValue) FetchEnumCompletions() []protocol.CompletionItem
 		kind := protocol.CompletionItemKindField
 		val := v.Values[enumKey]
 		description := val.GetTypeDescription()
+		insertText := enumKey.InsertText + v.Separator
 
 		var documentation string
 
@@ -125,6 +126,7 @@ func (v KeyEnumAssignmentValue) FetchEnumCompletions() []protocol.CompletionItem
 
 		completions = append(completions, protocol.CompletionItem{
 			Label:            enumKey.InsertText,
+			InsertText:       &insertText,
 			InsertTextFormat: &textFormat,
 			Kind:             &kind,
 			Documentation:    documentation,

handlers/fstab/documentation/documentation-mountoptions.go

@@ -285,4 +285,56 @@ 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,
+	),
+	"usbfs": createMountOptionField(
+		commondocumentation.UsbfsDocumentationEnums,
+		commondocumentation.UsbfsDocumentationAssignable,
+	),
+	"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,
+	),
 }

handlers/fstab/parser.go

@@ -211,6 +211,11 @@ func (p *FstabParser) AddLine(line string, lineNumber int) error {
 	case 6:
 		value := fields[5]
 		start := uint32(strings.Index(line, value))
+
+		if start == 0 {
+			start = uint32(len(line))
+		}
+
 		pass = &Field{
 			Value: fields[5],
 			Start: start,
@@ -221,6 +226,10 @@ func (p *FstabParser) AddLine(line string, lineNumber int) error {
 		value := fields[4]
 		start := uint32(strings.Index(line, value))
 
+		if start == 0 {
+			start = uint32(len(line))
+		}
+
 		freq = &Field{
 			Value: value,
 			Start: start,
@@ -231,6 +240,10 @@ func (p *FstabParser) AddLine(line string, lineNumber int) error {
 		value := fields[3]
 		start := uint32(strings.Index(line, value))
 
+		if start == 0 {
+			start = uint32(len(line))
+		}
+
 		options = &Field{
 			Value: value,
 			Start: start,
@@ -241,6 +254,10 @@ func (p *FstabParser) AddLine(line string, lineNumber int) error {
 		value := fields[2]
 		start := uint32(strings.Index(line, value))
 
+		if start == 0 {
+			start = uint32(len(line))
+		}
+
 		filesystemType = &Field{
 			Value: value,
 			Start: start,
@@ -251,6 +268,10 @@ func (p *FstabParser) AddLine(line string, lineNumber int) error {
 		value := fields[1]
 		start := uint32(strings.Index(line, value))
 
+		if start == 0 {
+			start = uint32(len(line))
+		}
+
 		mountPoint = &Field{
 			Value: value,
 			Start: start,

handlers/fstab/text-document-completion.go

@@ -3,7 +3,6 @@ package fstab
 import (
 	docvalues "config-lsp/doc-values"
 	fstabdocumentation "config-lsp/handlers/fstab/documentation"
-	"fmt"
 
 	"github.com/tliron/glsp"
 	protocol "github.com/tliron/glsp/protocol_3_16"

utils/common.go

@@ -61,6 +61,21 @@ func FilterWhere[T any](values []T, f func(T) bool) []T {
 	return result
 }
 
+func FilterMap[T comparable, O any](
+	values map[T]O,
+	f func(T, O) bool,
+) map[T]O {
+	result := make(map[T]O)
+
+	for key, value := range values {
+		if f(key, value) {
+			result[key] = value
+		}
+	}
+
+	return result
+}
+
 func FilterMapWhere[T comparable, O any](values map[T]O, f func(T, O) bool) map[T]O {
 	result := make(map[T]O)