Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0-or-later
       2             : /*
       3             :  * Scatterlist Cryptographic API.
       4             :  *
       5             :  * Procfs information.
       6             :  *
       7             :  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
       8             :  * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
       9             :  */
      10             : 
      11             : #include <linux/atomic.h>
      12             : #include <linux/init.h>
      13             : #include <linux/crypto.h>
      14             : #include <linux/module.h> /* for module_name() */
      15             : #include <linux/rwsem.h>
      16             : #include <linux/proc_fs.h>
      17             : #include <linux/seq_file.h>
      18             : #include "internal.h"
      19             : 
      20           0 : static void *c_start(struct seq_file *m, loff_t *pos)
      21             : {
      22           0 :         down_read(&crypto_alg_sem);
      23           0 :         return seq_list_start(&crypto_alg_list, *pos);
      24             : }
      25             : 
      26           0 : static void *c_next(struct seq_file *m, void *p, loff_t *pos)
      27             : {
      28           0 :         return seq_list_next(p, &crypto_alg_list, pos);
      29             : }
      30             : 
      31           0 : static void c_stop(struct seq_file *m, void *p)
      32             : {
      33           0 :         up_read(&crypto_alg_sem);
      34           0 : }
      35             : 
      36           0 : static int c_show(struct seq_file *m, void *p)
      37             : {
      38           0 :         struct crypto_alg *alg = list_entry(p, struct crypto_alg, cra_list);
      39             : 
      40           0 :         seq_printf(m, "name         : %s\n", alg->cra_name);
      41           0 :         seq_printf(m, "driver       : %s\n", alg->cra_driver_name);
      42           0 :         seq_printf(m, "module       : %s\n", module_name(alg->cra_module));
      43           0 :         seq_printf(m, "priority     : %d\n", alg->cra_priority);
      44           0 :         seq_printf(m, "refcnt       : %u\n", refcount_read(&alg->cra_refcnt));
      45           0 :         seq_printf(m, "selftest     : %s\n",
      46           0 :                    (alg->cra_flags & CRYPTO_ALG_TESTED) ?
      47             :                    "passed" : "unknown");
      48           0 :         seq_printf(m, "internal     : %s\n",
      49           0 :                    (alg->cra_flags & CRYPTO_ALG_INTERNAL) ?
      50             :                    "yes" : "no");
      51             : 
      52           0 :         if (alg->cra_flags & CRYPTO_ALG_LARVAL) {
      53           0 :                 seq_printf(m, "type         : larval\n");
      54           0 :                 seq_printf(m, "flags        : 0x%x\n", alg->cra_flags);
      55           0 :                 goto out;
      56             :         }
      57             : 
      58           0 :         if (alg->cra_type && alg->cra_type->show) {
      59           0 :                 alg->cra_type->show(m, alg);
      60           0 :                 goto out;
      61             :         }
      62             : 
      63           0 :         switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
      64           0 :         case CRYPTO_ALG_TYPE_CIPHER:
      65           0 :                 seq_printf(m, "type         : cipher\n");
      66           0 :                 seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
      67           0 :                 seq_printf(m, "min keysize  : %u\n",
      68             :                                         alg->cra_cipher.cia_min_keysize);
      69           0 :                 seq_printf(m, "max keysize  : %u\n",
      70             :                                         alg->cra_cipher.cia_max_keysize);
      71           0 :                 break;
      72           0 :         case CRYPTO_ALG_TYPE_COMPRESS:
      73           0 :                 seq_printf(m, "type         : compression\n");
      74           0 :                 break;
      75           0 :         default:
      76           0 :                 seq_printf(m, "type         : unknown\n");
      77           0 :                 break;
      78             :         }
      79             : 
      80           0 : out:
      81           0 :         seq_putc(m, '\n');
      82           0 :         return 0;
      83             : }
      84             : 
      85             : static const struct seq_operations crypto_seq_ops = {
      86             :         .start          = c_start,
      87             :         .next           = c_next,
      88             :         .stop           = c_stop,
      89             :         .show           = c_show
      90             : };
      91             : 
      92           1 : void __init crypto_init_proc(void)
      93             : {
      94           1 :         proc_create_seq("crypto", 0, NULL, &crypto_seq_ops);
      95           1 : }
      96             : 
      97           0 : void __exit crypto_exit_proc(void)
      98             : {
      99           0 :         remove_proc_entry("crypto", NULL);
     100           0 : }