fs: push i_mutex and filemap_write_and_wait down into ->fsync() handlers
[linux-3.10.git] / fs / ecryptfs / debug.c
1 /**
2  * eCryptfs: Linux filesystem encryption layer
3  * Functions only useful for debugging.
4  *
5  * Copyright (C) 2006 International Business Machines Corp.
6  *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of the
11  * License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21  * 02111-1307, USA.
22  */
23
24 #include "ecryptfs_kernel.h"
25
26 /**
27  * ecryptfs_dump_auth_tok - debug function to print auth toks
28  *
29  * This function will print the contents of an ecryptfs authentication
30  * token.
31  */
32 void ecryptfs_dump_auth_tok(struct ecryptfs_auth_tok *auth_tok)
33 {
34         char salt[ECRYPTFS_SALT_SIZE * 2 + 1];
35         char sig[ECRYPTFS_SIG_SIZE_HEX + 1];
36
37         ecryptfs_printk(KERN_DEBUG, "Auth tok at mem loc [%p]:\n",
38                         auth_tok);
39         if (auth_tok->flags & ECRYPTFS_PRIVATE_KEY) {
40                 ecryptfs_printk(KERN_DEBUG, " * private key type\n");
41         } else {
42                 ecryptfs_printk(KERN_DEBUG, " * passphrase type\n");
43                 ecryptfs_to_hex(salt, auth_tok->token.password.salt,
44                                 ECRYPTFS_SALT_SIZE);
45                 salt[ECRYPTFS_SALT_SIZE * 2] = '\0';
46                 ecryptfs_printk(KERN_DEBUG, " * salt = [%s]\n", salt);
47                 if (auth_tok->token.password.flags &
48                     ECRYPTFS_PERSISTENT_PASSWORD) {
49                         ecryptfs_printk(KERN_DEBUG, " * persistent\n");
50                 }
51                 memcpy(sig, auth_tok->token.password.signature,
52                        ECRYPTFS_SIG_SIZE_HEX);
53                 sig[ECRYPTFS_SIG_SIZE_HEX] = '\0';
54                 ecryptfs_printk(KERN_DEBUG, " * signature = [%s]\n", sig);
55         }
56         ecryptfs_printk(KERN_DEBUG, " * session_key.flags = [0x%x]\n",
57                         auth_tok->session_key.flags);
58         if (auth_tok->session_key.flags
59             & ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT)
60                 ecryptfs_printk(KERN_DEBUG,
61                                 " * Userspace decrypt request set\n");
62         if (auth_tok->session_key.flags
63             & ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT)
64                 ecryptfs_printk(KERN_DEBUG,
65                                 " * Userspace encrypt request set\n");
66         if (auth_tok->session_key.flags & ECRYPTFS_CONTAINS_DECRYPTED_KEY) {
67                 ecryptfs_printk(KERN_DEBUG, " * Contains decrypted key\n");
68                 ecryptfs_printk(KERN_DEBUG,
69                                 " * session_key.decrypted_key_size = [0x%x]\n",
70                                 auth_tok->session_key.decrypted_key_size);
71                 ecryptfs_printk(KERN_DEBUG, " * Decrypted session key "
72                                 "dump:\n");
73                 if (ecryptfs_verbosity > 0)
74                         ecryptfs_dump_hex(auth_tok->session_key.decrypted_key,
75                                           ECRYPTFS_DEFAULT_KEY_BYTES);
76         }
77         if (auth_tok->session_key.flags & ECRYPTFS_CONTAINS_ENCRYPTED_KEY) {
78                 ecryptfs_printk(KERN_DEBUG, " * Contains encrypted key\n");
79                 ecryptfs_printk(KERN_DEBUG,
80                                 " * session_key.encrypted_key_size = [0x%x]\n",
81                                 auth_tok->session_key.encrypted_key_size);
82                 ecryptfs_printk(KERN_DEBUG, " * Encrypted session key "
83                                 "dump:\n");
84                 if (ecryptfs_verbosity > 0)
85                         ecryptfs_dump_hex(auth_tok->session_key.encrypted_key,
86                                           auth_tok->session_key.
87                                           encrypted_key_size);
88         }
89 }
90
91 /**
92  * ecryptfs_dump_hex - debug hex printer
93  * @data: string of bytes to be printed
94  * @bytes: number of bytes to print
95  *
96  * Dump hexadecimal representation of char array
97  */
98 void ecryptfs_dump_hex(char *data, int bytes)
99 {
100         int i = 0;
101         int add_newline = 1;
102
103         if (ecryptfs_verbosity < 1)
104                 return;
105         if (bytes != 0) {
106                 printk(KERN_DEBUG "0x%.2x.", (unsigned char)data[i]);
107                 i++;
108         }
109         while (i < bytes) {
110                 printk("0x%.2x.", (unsigned char)data[i]);
111                 i++;
112                 if (i % 16 == 0) {
113                         printk("\n");
114                         add_newline = 0;
115                 } else
116                         add_newline = 1;
117         }
118         if (add_newline)
119                 printk("\n");
120 }
121