Branch data     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 | CRYPTO_ALG_LARVAL)) {
      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                 :         13 : void __init crypto_init_proc(void)
      93                 :            : {
      94                 :         13 :         proc_create_seq("crypto", 0, NULL, &crypto_seq_ops);
      95                 :         13 : }
      96                 :            : 
      97                 :          0 : void __exit crypto_exit_proc(void)
      98                 :            : {
      99                 :          0 :         remove_proc_entry("crypto", NULL);
     100                 :          0 : }