Disable pristine-tar option in gbp.conf, since there is no pristine-tar branch.

[bcachefs-tools-debian] / libbcachefs / checksum.c

diff --git a/libbcachefs/checksum.c b/libbcachefs/checksum.c
index 36939020f67d11e2d291c1195ecd2163b1e87e49..4701457f6381ca820e17a12707009c272ed5b4ac 100644 (file)
--- a/libbcachefs/checksum.c
+++ b/libbcachefs/checksum.c
@@ -139,7 +139,7 @@ static inline int do_encrypt(struct crypto_sync_skcipher *tfm,
 
                for (i = 0; i < pages; i++) {
                        unsigned offset = offset_in_page(buf);
-                       unsigned pg_len = min(len, PAGE_SIZE - offset);
+                       unsigned pg_len = min_t(size_t, len, PAGE_SIZE - offset);
 
                        sg_set_page(sg + i, vmalloc_to_page(buf), pg_len, offset);
                        buf += pg_len;
@@ -159,15 +159,16 @@ int bch2_chacha_encrypt_key(struct bch_key *key, struct nonce nonce,
                crypto_alloc_sync_skcipher("chacha20", 0, 0);
        int ret;
 
-       if (!chacha20) {
-               pr_err("error requesting chacha20 module: %li", PTR_ERR(chacha20));
-               return PTR_ERR(chacha20);
+       ret = PTR_ERR_OR_ZERO(chacha20);
+       if (ret) {
+               pr_err("error requesting chacha20 cipher: %s", bch2_err_str(ret));
+               return ret;
        }
 
        ret = crypto_skcipher_setkey(&chacha20->base,
                                     (void *) key, sizeof(*key));
        if (ret) {
-               pr_err("crypto_skcipher_setkey() error: %i", ret);
+               pr_err("error from crypto_skcipher_setkey(): %s", bch2_err_str(ret));
                goto err;
        }
 
@@ -361,18 +362,18 @@ struct bch_csum bch2_checksum_merge(unsigned type, struct bch_csum a,
 
        state.type = type;
        bch2_checksum_init(&state);
-       state.seed = (u64 __force) a.lo;
+       state.seed = le64_to_cpu(a.lo);
 
        BUG_ON(!bch2_checksum_mergeable(type));
 
        while (b_len) {
-               unsigned b = min_t(unsigned, b_len, PAGE_SIZE);
+               unsigned page_len = min_t(unsigned, b_len, PAGE_SIZE);
 
                bch2_checksum_update(&state,
-                               page_address(ZERO_PAGE(0)), b);
-               b_len -= b;
+                               page_address(ZERO_PAGE(0)), page_len);
+               b_len -= page_len;
        }
-       a.lo = (__le64 __force) bch2_checksum_final(&state);
+       a.lo = cpu_to_le64(bch2_checksum_final(&state));
        a.lo ^= b.lo;
        a.hi ^= b.hi;
        return a;
@@ -395,9 +396,9 @@ int bch2_rechecksum_bio(struct bch_fs *c, struct bio *bio,
                unsigned                        csum_type;
                struct bch_csum                 csum;
        } splits[3] = {
-               { crc_a, len_a, new_csum_type },
-               { crc_b, len_b, new_csum_type },
-               { NULL,  bio_sectors(bio) - len_a - len_b, new_csum_type },
+               { crc_a, len_a, new_csum_type, { 0 }},
+               { crc_b, len_b, new_csum_type, { 0 } },
+               { NULL,  bio_sectors(bio) - len_a - len_b, new_csum_type, { 0 } },
        }, *i;
        bool mergeable = crc_old.csum_type == new_csum_type &&
                bch2_checksum_mergeable(new_csum_type);
@@ -533,16 +534,31 @@ static int __bch2_request_key(char *key_description, struct bch_key *key)
 {
        key_serial_t key_id;
 
+       key_id = request_key("user", key_description, NULL,
+                            KEY_SPEC_SESSION_KEYRING);
+       if (key_id >= 0)
+               goto got_key;
+
        key_id = request_key("user", key_description, NULL,
                             KEY_SPEC_USER_KEYRING);
-       if (key_id < 0)
-               return -errno;
+       if (key_id >= 0)
+               goto got_key;
+
+       key_id = request_key("user", key_description, NULL,
+                            KEY_SPEC_USER_SESSION_KEYRING);
+       if (key_id >= 0)
+               goto got_key;
+
+       return -errno;
+got_key:
 
        if (keyctl_read(key_id, (void *) key, sizeof(*key)) != sizeof(*key))
                return -1;
 
        return 0;
 }
+
+#include "crypto.h"
 #endif
 
 int bch2_request_key(struct bch_sb *sb, struct bch_key *key)
@@ -555,9 +571,43 @@ int bch2_request_key(struct bch_sb *sb, struct bch_key *key)
 
        ret = __bch2_request_key(key_description.buf, key);
        printbuf_exit(&key_description);
+
+#ifndef __KERNEL__
+       if (ret) {
+               char *passphrase = read_passphrase("Enter passphrase: ");
+               struct bch_encrypted_key sb_key;
+
+               bch2_passphrase_check(sb, passphrase,
+                                     key, &sb_key);
+               ret = 0;
+       }
+#endif
+
+       /* stash with memfd, pass memfd fd to mount */
+
        return ret;
 }
 
+#ifndef __KERNEL__
+int bch2_revoke_key(struct bch_sb *sb)
+{
+       key_serial_t key_id;
+       struct printbuf key_description = PRINTBUF;
+
+       prt_printf(&key_description, "bcachefs:");
+       pr_uuid(&key_description, sb->user_uuid.b);
+
+       key_id = request_key("user", key_description.buf, NULL, KEY_SPEC_USER_KEYRING);
+       printbuf_exit(&key_description);
+       if (key_id < 0)
+               return errno;
+
+       keyctl_revoke(key_id);
+
+       return 0;
+}
+#endif
+
 int bch2_decrypt_sb_key(struct bch_fs *c,
                        struct bch_sb_field_crypt *crypt,
                        struct bch_key *key)
@@ -578,7 +628,7 @@ int bch2_decrypt_sb_key(struct bch_fs *c,
 
        /* decrypt real key: */
        ret = bch2_chacha_encrypt_key(&user_key, bch2_sb_key_nonce(c),
-                            &sb_key, sizeof(sb_key));
+                                     &sb_key, sizeof(sb_key));
        if (ret)
                goto err;
 
@@ -628,7 +678,7 @@ int bch2_disable_encryption(struct bch_fs *c)
 
        mutex_lock(&c->sb_lock);
 
-       crypt = bch2_sb_get_crypt(c->disk_sb.sb);
+       crypt = bch2_sb_field_get(c->disk_sb.sb, crypt);
        if (!crypt)
                goto out;
 
@@ -662,7 +712,7 @@ int bch2_enable_encryption(struct bch_fs *c, bool keyed)
        mutex_lock(&c->sb_lock);
 
        /* Do we already have an encryption key? */
-       if (bch2_sb_get_crypt(c->disk_sb.sb))
+       if (bch2_sb_field_get(c->disk_sb.sb, crypt))
                goto err;
 
        ret = bch2_alloc_ciphers(c);
@@ -690,7 +740,8 @@ int bch2_enable_encryption(struct bch_fs *c, bool keyed)
        if (ret)
                goto err;
 
-       crypt = bch2_sb_resize_crypt(&c->disk_sb, sizeof(*crypt) / sizeof(u64));
+       crypt = bch2_sb_field_resize(&c->disk_sb, crypt,
+                                    sizeof(*crypt) / sizeof(u64));
        if (!crypt) {
                ret = -BCH_ERR_ENOSPC_sb_crypt;
                goto err;
@@ -731,7 +782,7 @@ int bch2_fs_encryption_init(struct bch_fs *c)
                goto out;
        }
 
-       crypt = bch2_sb_get_crypt(c->disk_sb.sb);
+       crypt = bch2_sb_field_get(c->disk_sb.sb, crypt);
        if (!crypt)
                goto out;