efivarfs: expose used and total size

When writing EFI variables, one might get errors with no other message
on why it fails. Being able to see how much is used by EFI variables
helps analyzing such issues.

Since this is not a conventional filesystem, block size is intentionally
set to 1 instead of PAGE_SIZE.

x86 quirks of reserved size are taken into account; so that available
and free size can be different, further helping debugging space issues.

With this patch, one can see the remaining space in EFI variable storage
via efivarfs, like this:

   $ df -h /sys/firmware/efi/efivars/
   Filesystem      Size  Used Avail Use% Mounted on
   efivarfs        176K  106K   66K  62% /sys/firmware/efi/efivars

Signed-off-by: Anisse Astier <an.astier@criteo.com>
[ardb: - rename efi_reserved_space() to efivar_reserved_space()
       - whitespace/coding style tweaks]
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>

diff --git a/arch/x86/platform/efi/quirks.c b/arch/x86/platform/efi/quirks.c
index b0b848d6933afbcf118415ea6689488e28675054..f0cc00032751d063955e10ee556b08ca4b3806a9 100644 (file)
--- a/arch/x86/platform/efi/quirks.c
+++ b/arch/x86/platform/efi/quirks.c
@@ -114,6 +114,14 @@ void efi_delete_dummy_variable(void)
                                     EFI_VARIABLE_RUNTIME_ACCESS, 0, NULL);
 }
 
+u64 efivar_reserved_space(void)
+{
+       if (efi_no_storage_paranoia)
+               return 0;
+       return EFI_MIN_RESERVE;
+}
+EXPORT_SYMBOL_GPL(efivar_reserved_space);
+
 /*
  * In the nonblocking case we do not attempt to perform garbage
  * collection if we do not have enough free space. Rather, we do the

diff --git a/drivers/firmware/efi/efi.c b/drivers/firmware/efi/efi.c
index abeff7dc0b581f8661b2d6a22edeb108d36497a6..d0dfa007bffcc14829afa06bc6789a1193deed3e 100644 (file)
--- a/drivers/firmware/efi/efi.c
+++ b/drivers/firmware/efi/efi.c
@@ -211,6 +211,7 @@ static int generic_ops_register(void)
        generic_ops.get_variable = efi.get_variable;
        generic_ops.get_next_variable = efi.get_next_variable;
        generic_ops.query_variable_store = efi_query_variable_store;
+       generic_ops.query_variable_info = efi.query_variable_info;
 
        if (efi_rt_services_supported(EFI_RT_SUPPORTED_SET_VARIABLE)) {
                generic_ops.set_variable = efi.set_variable;

diff --git a/drivers/firmware/efi/vars.c b/drivers/firmware/efi/vars.c
index bfc5fa6aa47b687cc43623b3a238d8564ac1565e..e9dc7116daf133e68750ed7148f2661f6c5ffc34 100644 (file)
--- a/drivers/firmware/efi/vars.c
+++ b/drivers/firmware/efi/vars.c
@@ -245,3 +245,15 @@ efi_status_t efivar_set_variable(efi_char16_t *name, efi_guid_t *vendor,
        return status;
 }
 EXPORT_SYMBOL_NS_GPL(efivar_set_variable, EFIVAR);
+
+efi_status_t efivar_query_variable_info(u32 attr,
+                                       u64 *storage_space,
+                                       u64 *remaining_space,
+                                       u64 *max_variable_size)
+{
+       if (!__efivars->ops->query_variable_info)
+               return EFI_UNSUPPORTED;
+       return __efivars->ops->query_variable_info(attr, storage_space,
+                       remaining_space, max_variable_size);
+}
+EXPORT_SYMBOL_NS_GPL(efivar_query_variable_info, EFIVAR);

diff --git a/fs/efivarfs/super.c b/fs/efivarfs/super.c
index 482d612b716bb1f06b10b7dd7fced44f85eafffd..e028fafa04f38c51739bb56c796bb5d854c7c4ba 100644 (file)
--- a/fs/efivarfs/super.c
+++ b/fs/efivarfs/super.c
@@ -13,6 +13,7 @@
 #include <linux/ucs2_string.h>
 #include <linux/slab.h>
 #include <linux/magic.h>
+#include <linux/statfs.h>
 
 #include "internal.h"
 
@@ -23,8 +24,44 @@ static void efivarfs_evict_inode(struct inode *inode)
        clear_inode(inode);
 }
 
+static int efivarfs_statfs(struct dentry *dentry, struct kstatfs *buf)
+{
+       const u32 attr = EFI_VARIABLE_NON_VOLATILE |
+                        EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                        EFI_VARIABLE_RUNTIME_ACCESS;
+       u64 storage_space, remaining_space, max_variable_size;
+       efi_status_t status;
+
+       status = efivar_query_variable_info(attr, &storage_space, &remaining_space,
+                                           &max_variable_size);
+       if (status != EFI_SUCCESS)
+               return efi_status_to_err(status);
+
+       /*
+        * This is not a normal filesystem, so no point in pretending it has a block
+        * size; we declare f_bsize to 1, so that we can then report the exact value
+        * sent by EFI QueryVariableInfo in f_blocks and f_bfree
+        */
+       buf->f_bsize    = 1;
+       buf->f_namelen  = NAME_MAX;
+       buf->f_blocks   = storage_space;
+       buf->f_bfree    = remaining_space;
+       buf->f_type     = dentry->d_sb->s_magic;
+
+       /*
+        * In f_bavail we declare the free space that the kernel will allow writing
+        * when the storage_paranoia x86 quirk is active. To use more, users
+        * should boot the kernel with efi_no_storage_paranoia.
+        */
+       if (remaining_space > efivar_reserved_space())
+               buf->f_bavail = remaining_space - efivar_reserved_space();
+       else
+               buf->f_bavail = 0;
+
+       return 0;
+}
 static const struct super_operations efivarfs_ops = {
-       .statfs = simple_statfs,
+       .statfs = efivarfs_statfs,
        .drop_inode = generic_delete_inode,
        .evict_inode = efivarfs_evict_inode,
 };

diff --git a/include/linux/efi.h b/include/linux/efi.h
index 7aa62c92185f6467069fe07aedb8cf4e0041d352..bed3c92cbc3180f000428834f17c885e08b6073a 100644 (file)
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -1042,6 +1042,7 @@ struct efivar_operations {
        efi_set_variable_t *set_variable;
        efi_set_variable_t *set_variable_nonblocking;
        efi_query_variable_store_t *query_variable_store;
+       efi_query_variable_info_t *query_variable_info;
 };
 
 struct efivars {
@@ -1049,6 +1050,12 @@ struct efivars {
        const struct efivar_operations *ops;
 };
 
+#ifdef CONFIG_X86
+u64 __attribute_const__ efivar_reserved_space(void);
+#else
+static inline u64 efivar_reserved_space(void) { return 0; }
+#endif
+
 /*
  * The maximum size of VariableName + Data = 1024
  * Therefore, it's reasonable to save that much
@@ -1087,6 +1094,10 @@ efi_status_t efivar_set_variable_locked(efi_char16_t *name, efi_guid_t *vendor,
 efi_status_t efivar_set_variable(efi_char16_t *name, efi_guid_t *vendor,
                                 u32 attr, unsigned long data_size, void *data);
 
+efi_status_t efivar_query_variable_info(u32 attr, u64 *storage_space,
+                                       u64 *remaining_space,
+                                       u64 *max_variable_size);
+
 #if IS_ENABLED(CONFIG_EFI_CAPSULE_LOADER)
 extern bool efi_capsule_pending(int *reset_type);