Commit | Line | Data |
---|---|---|
26780d9e BG |
1 | /* |
2 | * linux/drivers/scsi/esas2r/esas2r_log.c | |
3 | * For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers | |
4 | * | |
5 | * Copyright (c) 2001-2013 ATTO Technology, Inc. | |
6 | * (mailto:linuxdrivers@attotech.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 | |
10 | * as published by the Free Software Foundation; either version 2 | |
11 | * of the License, or (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * NO WARRANTY | |
19 | * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR | |
20 | * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT | |
21 | * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, | |
22 | * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is | |
23 | * solely responsible for determining the appropriateness of using and | |
24 | * distributing the Program and assumes all risks associated with its | |
25 | * exercise of rights under this Agreement, including but not limited to | |
26 | * the risks and costs of program errors, damage to or loss of data, | |
27 | * programs or equipment, and unavailability or interruption of operations. | |
28 | * | |
29 | * DISCLAIMER OF LIABILITY | |
30 | * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY | |
31 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
32 | * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND | |
33 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR | |
34 | * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE | |
35 | * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED | |
36 | * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES | |
37 | * | |
38 | * You should have received a copy of the GNU General Public License | |
39 | * along with this program; if not, write to the Free Software | |
40 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, | |
41 | * USA. | |
42 | */ | |
43 | ||
44 | #include "esas2r.h" | |
45 | ||
46 | /* | |
47 | * this module within the driver is tasked with providing logging functionality. | |
48 | * the event_log_level module parameter controls the level of messages that are | |
49 | * written to the system log. the default level of messages that are written | |
50 | * are critical and warning messages. if other types of messages are desired, | |
51 | * one simply needs to load the module with the correct value for the | |
52 | * event_log_level module parameter. for example: | |
53 | * | |
54 | * insmod <module> event_log_level=1 | |
55 | * | |
56 | * will load the module and only critical events will be written by this module | |
57 | * to the system log. if critical, warning, and information-level messages are | |
58 | * desired, the correct value for the event_log_level module parameter | |
59 | * would be as follows: | |
60 | * | |
61 | * insmod <module> event_log_level=3 | |
62 | */ | |
63 | ||
64 | #define EVENT_LOG_BUFF_SIZE 1024 | |
65 | ||
66 | static long event_log_level = ESAS2R_LOG_DFLT; | |
67 | ||
68 | module_param(event_log_level, long, S_IRUGO | S_IRUSR); | |
69 | MODULE_PARM_DESC(event_log_level, | |
70 | "Specifies the level of events to report to the system log. Critical and warning level events are logged by default."); | |
71 | ||
72 | /* A shared buffer to use for formatting messages. */ | |
73 | static char event_buffer[EVENT_LOG_BUFF_SIZE]; | |
74 | ||
75 | /* A lock to protect the shared buffer used for formatting messages. */ | |
76 | static DEFINE_SPINLOCK(event_buffer_lock); | |
77 | ||
78 | /** | |
79 | * translates an esas2r-defined logging event level to a kernel logging level. | |
80 | * | |
81 | * @param [in] level the esas2r-defined logging event level to translate | |
82 | * | |
83 | * @return the corresponding kernel logging level. | |
84 | */ | |
85 | static const char *translate_esas2r_event_level_to_kernel(const long level) | |
86 | { | |
87 | switch (level) { | |
88 | case ESAS2R_LOG_CRIT: | |
89 | return KERN_CRIT; | |
90 | ||
91 | case ESAS2R_LOG_WARN: | |
92 | return KERN_WARNING; | |
93 | ||
94 | case ESAS2R_LOG_INFO: | |
95 | return KERN_INFO; | |
96 | ||
97 | case ESAS2R_LOG_DEBG: | |
98 | case ESAS2R_LOG_TRCE: | |
99 | default: | |
100 | return KERN_DEBUG; | |
101 | } | |
102 | } | |
103 | ||
104 | /** | |
105 | * the master logging function. this function will format the message as | |
106 | * outlined by the formatting string, the input device information and the | |
107 | * substitution arguments and output the resulting string to the system log. | |
108 | * | |
109 | * @param [in] level the event log level of the message | |
110 | * @param [in] dev the device information | |
111 | * @param [in] format the formatting string for the message | |
112 | * @param [in] args the substition arguments to the formatting string | |
113 | * | |
114 | * @return 0 on success, or -1 if an error occurred. | |
115 | */ | |
116 | static int esas2r_log_master(const long level, | |
117 | const struct device *dev, | |
118 | const char *format, | |
119 | va_list args) | |
120 | { | |
121 | if (level <= event_log_level) { | |
122 | unsigned long flags = 0; | |
123 | int retval = 0; | |
124 | char *buffer = event_buffer; | |
125 | size_t buflen = EVENT_LOG_BUFF_SIZE; | |
126 | const char *fmt_nodev = "%s%s: "; | |
127 | const char *fmt_dev = "%s%s [%s, %s, %s]"; | |
128 | const char *slevel = | |
129 | translate_esas2r_event_level_to_kernel(level); | |
130 | ||
131 | spin_lock_irqsave(&event_buffer_lock, flags); | |
132 | ||
133 | if (buffer == NULL) { | |
134 | spin_unlock_irqrestore(&event_buffer_lock, flags); | |
135 | return -1; | |
136 | } | |
137 | ||
138 | memset(buffer, 0, buflen); | |
139 | ||
140 | /* | |
141 | * format the level onto the beginning of the string and do | |
142 | * some pointer arithmetic to move the pointer to the point | |
143 | * where the actual message can be inserted. | |
144 | */ | |
145 | ||
146 | if (dev == NULL) { | |
147 | snprintf(buffer, buflen, fmt_nodev, slevel, | |
148 | ESAS2R_DRVR_NAME); | |
149 | } else { | |
150 | snprintf(buffer, buflen, fmt_dev, slevel, | |
151 | ESAS2R_DRVR_NAME, | |
152 | (dev->driver ? dev->driver->name : "unknown"), | |
153 | (dev->bus ? dev->bus->name : "unknown"), | |
154 | dev_name(dev)); | |
155 | } | |
156 | ||
157 | buffer += strlen(event_buffer); | |
158 | buflen -= strlen(event_buffer); | |
159 | ||
160 | retval = vsnprintf(buffer, buflen, format, args); | |
161 | if (retval < 0) { | |
162 | spin_unlock_irqrestore(&event_buffer_lock, flags); | |
163 | return -1; | |
164 | } | |
165 | ||
166 | /* | |
167 | * Put a line break at the end of the formatted string so that | |
b9c24466 | 168 | * we don't wind up with run-on messages. |
26780d9e | 169 | */ |
b9c24466 | 170 | printk("%s\n", event_buffer); |
26780d9e BG |
171 | |
172 | spin_unlock_irqrestore(&event_buffer_lock, flags); | |
173 | } | |
174 | ||
175 | return 0; | |
176 | } | |
177 | ||
178 | /** | |
179 | * formats and logs a message to the system log. | |
180 | * | |
181 | * @param [in] level the event level of the message | |
182 | * @param [in] format the formating string for the message | |
183 | * @param [in] ... the substitution arguments to the formatting string | |
184 | * | |
185 | * @return 0 on success, or -1 if an error occurred. | |
186 | */ | |
187 | int esas2r_log(const long level, const char *format, ...) | |
188 | { | |
189 | int retval = 0; | |
190 | va_list args; | |
191 | ||
192 | va_start(args, format); | |
193 | ||
194 | retval = esas2r_log_master(level, NULL, format, args); | |
195 | ||
196 | va_end(args); | |
197 | ||
198 | return retval; | |
199 | } | |
200 | ||
201 | /** | |
202 | * formats and logs a message to the system log. this message will include | |
203 | * device information. | |
204 | * | |
205 | * @param [in] level the event level of the message | |
206 | * @param [in] dev the device information | |
207 | * @param [in] format the formatting string for the message | |
208 | * @param [in] ... the substitution arguments to the formatting string | |
209 | * | |
210 | * @return 0 on success, or -1 if an error occurred. | |
211 | */ | |
212 | int esas2r_log_dev(const long level, | |
213 | const struct device *dev, | |
214 | const char *format, | |
215 | ...) | |
216 | { | |
217 | int retval = 0; | |
218 | va_list args; | |
219 | ||
220 | va_start(args, format); | |
221 | ||
222 | retval = esas2r_log_master(level, dev, format, args); | |
223 | ||
224 | va_end(args); | |
225 | ||
226 | return retval; | |
227 | } | |
228 | ||
229 | /** | |
230 | * formats and logs a message to the system log. this message will include | |
231 | * device information. | |
232 | * | |
233 | * @param [in] level the event level of the message | |
234 | * @param [in] buf | |
235 | * @param [in] len | |
236 | * | |
237 | * @return 0 on success, or -1 if an error occurred. | |
238 | */ | |
239 | int esas2r_log_hexdump(const long level, | |
240 | const void *buf, | |
241 | size_t len) | |
242 | { | |
243 | if (level <= event_log_level) { | |
244 | print_hex_dump(translate_esas2r_event_level_to_kernel(level), | |
245 | "", DUMP_PREFIX_OFFSET, 16, 1, buf, | |
246 | len, true); | |
247 | } | |
248 | ||
249 | return 1; | |
250 | } |