?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / fs.d / nfs / nfslog / process_buffer.c
blobdf301a7ecacacd23525696f855ea0ae07f4de77e
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 #include <strings.h>
29 #include <string.h>
30 #include <syslog.h>
31 #include <locale.h>
32 #include <nfs/nfs.h>
33 #include <nfs/export.h>
34 #include <nfs/nfssys.h>
35 #include <nfs/nfs_log.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <stdio.h>
39 #include <errno.h>
40 #include <assert.h>
41 #include <stdlib.h>
42 #include <unistd.h>
43 #include <nfs/nfs_log.h>
44 #include "../lib/nfslog_config.h"
45 #include "buffer_list.h"
46 #include "nfslogd.h"
47
48 extern int _nfssys(int, void *);
49
50 /*
51 * simple list used to keep track of bad tag messages syslogged.
52 */
53 struct nfs_log_list {
54 char *l_name;
55 struct nfs_log_list *l_next;
56 };
57
58 static void badtag_notify(char *tag);
59 static struct nfs_log_list *badtag_list = NULL;
60
61 static void cleanup_elf_state(nfsl_config_t *);
62 static void cleanup_trans_state(nfsl_config_t *);
63
64 /*
65 * Read the contents of the 'bufferpath', process them and store the
66 * user-readable log in 'elfpath', updating the 'fhpath' filehandle
67 * table.
68 * The contents of the configuration list (*config_list) may be
69 * modified if the configuration file has been updated and we can not
70 * find the configuration entry in the currently loaded list.
71 *
72 * Returns 0 on success and sets *buffer_processed to 1.
73 * non zero error on failure and *buffer_processed set to 0.
74 */
75 int
76 process_buffer(
77 struct buffer_ent *bep,
78 nfsl_config_t **config_list,
79 int min_size,
80 int idle_time,
81 int *buffer_processed)
82 {
83 struct stat st;
84 struct nfsl_flush_args nfa;
85 struct nfslog_buf *lbp = NULL;
86 struct nfslog_lr *lrp;
87 char *path1 = NULL;
88 char *path2 = NULL;
89 char *buffer_inprog = NULL;
90 int buffer_inprog_len;
91 int error = 0;
92 nfsl_config_t *ncp = NULL, *last_good_ncp;
93 char *bufferpath = bep->be_name;
94 char *tag;
95 boolean_t elf_checked = B_FALSE;
96 boolean_t trans_checked = B_FALSE;
97
98 assert(buffer_processed != NULL);
99 assert(bufferpath != NULL);
100
101 if (stat(bufferpath, &st) == -1) {
102 error = errno;
103 if (error == ENOENT) {
104 error = 0;
105 buffer_inprog_len = strlen(bufferpath) +
106 strlen(LOG_INPROG_STRING) + 1;
107 buffer_inprog = (char *)malloc(buffer_inprog_len);
108 if (buffer_inprog == NULL) {
109 syslog(LOG_ERR, gettext(
110 "process_buffer: malloc failed"));
111 return (ENOMEM);
112 }
113 (void) sprintf(buffer_inprog, "%s%s", bufferpath,
114 LOG_INPROG_STRING);
115
116 if (stat(buffer_inprog, &st) == -1) {
117 error = errno;
118 if (bep->be_error != error) {
119 syslog(LOG_ERR, gettext(
120 "Can not stat %s: %s"),
121 buffer_inprog, strerror(error));
122 }
123 free(buffer_inprog);
124 return (error);
125 }
126
127 free(buffer_inprog);
128
129 /*
130 * Does the buffer in progress meet our minimum
131 * processing requirements? or has it been around
132 * longer than we're willing to wait for more
133 * data to be logged?
134 */
135 if ((st.st_size < min_size) &&
136 ((time(0) - bep->be_lastprocessed) < idle_time)) {
137 /*
138 * The buffer does not meet the minimum
139 * size processing requirements, and it has not
140 * been around longer than we're willing to
141 * wait for more data collection.
142 * We return now without processing it.
143 */
144 return (0);
145 }
146
147 /*
148 * Issue the LOG_FLUSH system call to flush the
149 * buffer and process it.
150 */
151 (void) memset((void *)&nfa, 0, sizeof (nfa));
152 nfa.version = NFSL_FLUSH_ARGS_VERS;
153 nfa.directive = NFSL_RENAME | NFSL_SYNC;
154 nfa.buff = bufferpath;
155 nfa.buff_len = strlen(bufferpath) + 1;
156
157 if (_nfssys(LOG_FLUSH, &nfa) < 0) {
158 error = errno;
159 if (bep->be_error != error) {
160 syslog(LOG_ERR, gettext(
161 "_nfssys(%s) failed: %s"),
162 nfa.buff, strerror(error));
163 }
164 return (error);
165 }
166 } else {
167 if (bep->be_error != error) {
168 syslog(LOG_ERR, gettext("Can not stat %s: %s"),
169 bufferpath, strerror(error));
170 }
171 return (error);
172 }
173 }
174
175 /*
176 * Open and lock input buffer.
177 * Passes in the value of the last error so that it will not
178 * print it again if it is still hitting the same error condition.
179 */
180 error = bep->be_error;
181 if ((lbp = nfslog_open_buf(bufferpath, &error)) == NULL)
182 goto done;
183
184 if ((ncp = last_good_ncp =
185 nfsl_findconfig(*config_list, "global", &error)) == NULL) {
186 assert(error != 0);
187 nfsl_freeconfig_list(config_list);
188 if (error != bep->be_error) {
189 syslog(LOG_ERR, gettext(
190 "Could not search config list: %s"),
191 strerror(error));
192 }
193 goto done;
194 }
195
196 assert(error == 0);
197 while ((lrp = nfslog_get_logrecord(lbp)) != NULL && keep_running) {
198
199 if (*buffer_processed == 0)
200 (*buffer_processed)++;
201
202 /*
203 * Get the matching config entry.
204 */
205 tag = lrp->log_record.re_tag;
206 if (strcmp(tag, last_good_ncp->nc_name) != 0) {
207 ncp = nfsl_findconfig(*config_list, tag, &error);
208 if (error) {
209 if (error != bep->be_error) {
210 syslog(LOG_ERR, gettext(
211 "Could not search config list: %s"),
212 strerror(error));
213 }
214 nfsl_freeconfig_list(config_list);
215 goto done;
216 }
217 if (ncp == NULL) {
218 badtag_notify(tag);
219 ncp = last_good_ncp;
220 goto skip;
221 }
222 last_good_ncp = ncp;
223 }
224
225 if (ncp->nc_flags & NC_UPDATED) {
226 /*
227 * The location of the log files may have changed,
228 * we need to close transactions and invalidate
229 * cookies so that the log files can be reopened
230 * further down.
231 */
232 cleanup_elf_state(ncp);
233 cleanup_trans_state(ncp);
234
235 ncp->nc_flags &= ~NC_UPDATED;
236
237 /*
238 * Force cookies to be recreated if necessary.
239 */
240 elf_checked = trans_checked = B_FALSE;
241 }
242
243 /*
244 * Open output files.
245 */
246 if (ncp->nc_rpclogpath != NULL) {
247 /*
248 * Log rpc requests in W3C-ELF format.
249 */
250 if (!elf_checked && ncp->nc_elfcookie != NULL) {
251 /*
252 * Make sure file still exists.
253 * Do this once per buffer.
254 */
255 if (stat(ncp->nc_rpclogpath, &st) == -1 &&
256 errno == ENOENT) {
257 /*
258 * The open rpclogfile has been
259 * deleted. Get new one below.
260 */
261 cleanup_elf_state(ncp);
262 }
263 elf_checked = B_TRUE;
264 }
265 if (ncp->nc_elfcookie == NULL) {
266 error = bep->be_error;
267 ncp->nc_elfcookie = nfslog_open_elf_file(
268 ncp->nc_rpclogpath, &lbp->bh, &error);
269 if (ncp->nc_elfcookie == NULL) {
270 bep->be_error = error;
271 goto done;
272 }
273 }
274 }
275
276 if (ncp->nc_logpath != NULL) {
277 /*
278 * Log rpc reqs in trans/ftp format.
279 */
280 if (!trans_checked && ncp->nc_transcookie != NULL) {
281 /*
282 * Do this once per buffer.
283 */
284 if (stat(ncp->nc_logpath, &st) == -1 &&
285 errno == ENOENT) {
286 /*
287 * The open transaction file has been
288 * deleted. Close pending transaction
289 * work. A new transaction log will be
290 * opened by nfslog_open_trans_file()
291 * below.
292 */
293 cleanup_trans_state(ncp);
294 }
295 trans_checked = B_TRUE;
296 }
297 if (ncp->nc_transcookie == NULL) {
298 int transtolog;
299
300 transtolog =
301 (ncp->nc_logformat == TRANSLOG_BASIC) ?
302 TRANSTOLOG_OPER_READWRITE : TRANSTOLOG_ALL;
303 error = bep->be_error;
304 ncp->nc_transcookie = nfslog_open_trans_file(
305 ncp->nc_logpath, ncp->nc_logformat,
306 transtolog, &error);
307 if (ncp->nc_transcookie == NULL) {
308 bep->be_error = error;
309 goto done;
310 }
311 }
312 }
313
314 assert(ncp->nc_fhpath != NULL);
315
316 if (nfslog_process_fh_rec(lrp, ncp->nc_fhpath, &path1, &path2,
317 ncp->nc_elfcookie != NULL)) {
318 /*
319 * Make sure there is room.
320 */
321 if (ncp->nc_elfcookie != NULL) {
322 (void) nfslog_process_elf_rec(ncp->nc_elfcookie,
323 &lrp->log_record, path1, path2);
324 }
325
326 if (ncp->nc_transcookie != NULL) {
327 (void) nfslog_process_trans_rec(
328 ncp->nc_transcookie,
329 &lrp->log_record, ncp->nc_fhpath,
330 path1, path2);
331 }
332 }
333
334 skip: if (path1 != NULL)
335 free(path1);
336 if (path2 != NULL)
337 free(path2);
338
339 path1 = path2 = NULL;
340 nfslog_free_logrecord(lrp, TRUE);
341 } /* while */
342
343 if (!error && keep_running) {
344 /*
345 * Keep track of when this buffer was last processed.
346 */
347 bep->be_lastprocessed = time(0);
348
349 if (test && *buffer_processed != 0) {
350 /*
351 * Save the buffer for future debugging. We do this
352 * by following the log cycling policy, with a maximum
353 * of 'max_logs_preserve' to save.
354 */
355 if (cycle_log(bufferpath, max_logs_preserve)) {
356 syslog(LOG_ERR, gettext(
357 "could not save copy of buffer \"%s\""),
358 bufferpath);
359 }
360 } else {
361 /*
362 * Remove buffer since it has been processed.
363 */
364 if (unlink(bufferpath)) {
365 error = errno;
366 syslog(LOG_ERR, gettext(
367 "could not unlink %s: %s"),
368 bufferpath, strerror(error));
369 /*
370 * Buffer was processed correctly.
371 */
372 error = 0;
373 }
374 }
375 }
376
377 done:
378 if (lbp != NULL)
379 nfslog_close_buf(lbp, quick_cleaning);
380 if (ncp && !quick_cleaning)
381 cleanup_elf_state(ncp);
382
383 return (error);
384 }
385
386 static void
387 cleanup_elf_state(nfsl_config_t *ncp)
388 {
389 if (ncp->nc_elfcookie != NULL) {
390 nfslog_close_elf_file(&ncp->nc_elfcookie);
391 assert(ncp->nc_elfcookie == NULL);
392 }
393 }
394
395 static void
396 cleanup_trans_state(nfsl_config_t *ncp)
397 {
398 if (ncp->nc_transcookie != NULL) {
399 nfslog_close_transactions(&ncp->nc_transcookie);
400 assert(ncp->nc_transcookie == NULL);
401 }
402 }
403
404 /*
405 * Searches the list of previously seen bad tags. Note that this
406 * list is never pruned. This should not be a problem since the
407 * list of bad tags should be fairl small. New entries are inserted
408 * at the beginning of the list assuming it will be accessed more
409 * frequently since we have just seen it.
410 */
411 static void
412 badtag_notify(char *tag)
413 {
414 struct nfs_log_list *lp, *p;
415 int error;
416
417 for (p = badtag_list; p != NULL; p = p->l_next) {
418 if (strcmp(tag, p->l_name) == 0) {
419 /*
420 * We've seen this before, nothing to do.
421 */
422 return;
423 }
424 }
425
426 /*
427 * Not on the list, add it.
428 */
429 syslog(LOG_ERR, gettext("tag \"%s\" not found in %s - "
430 "ignoring records referencing such tag."),
431 tag, NFSL_CONFIG_FILE_PATH);
432
433 if ((lp = (struct nfs_log_list *)malloc(sizeof (*lp))) != NULL) {
434 if ((lp->l_name = strdup(tag)) != NULL) {
435 lp->l_next = badtag_list;
436 badtag_list = lp;
437 return; /* done */
438 }
439 }
440
441 if (lp->l_name != NULL)
442 free(lp->l_name);
443 if (lp)
444 free(lp);
445 error = errno;
446 syslog(LOG_ERR, gettext(
447 "Cannot add \"%s\" to bad tag list: %s"), tag, strerror(error));
448 }
unleashed repo fork