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 (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 #include <sys/cred.h> 26 #include <sys/cmn_err.h> 27 #include <sys/debug.h> 28 #include <sys/systm.h> 29 #include <sys/kmem.h> 30 #include <sys/disp.h> 31 #include <sys/atomic.h> 32 #include <rpc/types.h> 33 #include <nfs/nfs.h> 34 #include <nfs/nfssys.h> 35 #include <nfs/export.h> 36 #include <nfs/rnode.h> 37 #include <rpc/auth.h> 38 #include <rpc/svc.h> 39 #include <rpc/xdr.h> 40 #include <rpc/clnt.h> 41 #include <nfs/nfs_log.h> 42 43 #define NUM_RECORDS_TO_WRITE 256 44 #define NUM_BYTES_TO_WRITE 65536 45 46 extern krwlock_t exported_lock; 47 48 static int nfslog_num_records_to_write = NUM_RECORDS_TO_WRITE; 49 static int nfslog_num_bytes_to_write = NUM_BYTES_TO_WRITE; 50 51 /* 52 * This struct is used to 'hide' the details of managing the log 53 * records internally to the logging code. Allocation routines 54 * are used to obtain pieces of memory for XDR encoding. This struct 55 * is a 'header' to those areas and a opaque cookie is used to pass 56 * this data structure between the allocating function and the put 57 * function. 58 */ 59 struct lr_alloc { 60 struct lr_alloc *next; /* links for write queuing */ 61 struct lr_alloc *prev; 62 #define LR_ALLOC_NOFREE 0x1 /* not present, call free */ 63 int lr_flags; 64 caddr_t log_record; /* address to XDR encoding */ 65 size_t size; /* final size of encoding */ 66 struct kmem_cache *alloc_cache; /* keep track of cache ptr */ 67 struct exportinfo *exi; /* who are we related to? */ 68 struct log_buffer *lb; 69 }; 70 71 struct flush_thread_params { 72 struct nfsl_flush_args tp_args; 73 int tp_error; 74 }; 75 76 static int log_file_create(caddr_t, struct log_file **); 77 static void log_file_rele(struct log_file *); 78 static struct log_buffer *log_buffer_create(caddr_t); 79 static void log_buffer_rele(struct log_buffer *); 80 static int nfslog_record_append2all(struct lr_alloc *); 81 static int nfslog_logbuffer_rename(struct log_buffer *); 82 static void nfslog_logfile_wait(struct log_file *); 83 static int nfslog_logfile_rename(char *, char *); 84 static void nfslog_do_flush(struct flush_thread_params *); 85 static void create_buffer_header(caddr_t *, size_t *, size_t *); 86 87 static int nfslog_write_logrecords(struct log_file *, struct lr_alloc *, int); 88 static void nfslog_free_logrecords(struct lr_alloc *); 89 static int nfslog_records_flush_to_disk(struct log_buffer *); 90 static int nfslog_records_flush_to_disk_nolock(struct log_buffer *); 91 92 /* 93 * Read/Write lock that protects 'nfslog_buffer_list'. 94 * This lock must be held when searching or modifying 'nfslog_buffer_list'. 95 */ 96 static krwlock_t nfslog_buffer_list_lock; 97 98 /* 99 * The list of "log_buffer" structures. 100 */ 101 struct log_buffer *nfslog_buffer_list = NULL; 102 103 104 #define LOG_BUFFER_HOLD(lbp) { \ 105 mutex_enter(&(lbp)->lb_lock); \ 106 (lbp)->lb_refcnt++; \ 107 mutex_exit(&(lbp)->lb_lock); \ 108 } 109 110 #define LOG_FILE_HOLD(lfp) { \ 111 mutex_enter(&(lfp)->lf_lock); \ 112 (lfp)->lf_refcnt++; \ 113 mutex_exit(&(lfp)->lf_lock); \ 114 } 115 116 #define LOG_FILE_RELE(lfp) { \ 117 log_file_rele(lfp); \ 118 } 119 120 /* 121 * These two macros are used to prep a logfile data structure and 122 * associated file for writing data. Note that the lf_lock is 123 * held as a result of the call to the first macro. This is used 124 * for serialization correctness between the logbuffer struct and 125 * the logfile struct. 126 */ 127 #define LOG_FILE_LOCK_TO_WRITE(lfp) { \ 128 mutex_enter(&(lfp)->lf_lock); \ 129 (lfp)->lf_refcnt++; \ 130 (lfp)->lf_writers++; \ 131 } 132 133 #define LOG_FILE_UNLOCK_FROM_WRITE(lfp) { \ 134 (lfp)->lf_writers--; \ 135 if ((lfp)->lf_writers == 0 && ((lfp)->lf_flags & L_WAITING)) { \ 136 (lfp)->lf_flags &= ~L_WAITING; \ 137 cv_broadcast(&(lfp)->lf_cv_waiters); \ 138 } \ 139 mutex_exit(&(lfp)->lf_lock); \ 140 log_file_rele(lfp); \ 141 } 142 143 int rfsl_log_buffer = 0; 144 static int rfsl_log_file = 0; 145 146 /* This array is used for memory allocation of record encoding spaces */ 147 static struct { 148 int size; 149 struct kmem_cache *mem_cache; 150 char *cache_name; 151 } nfslog_mem_alloc[] = { 152 #define SMALL_INDX 0 153 { NFSLOG_SMALL_RECORD_SIZE - sizeof (struct lr_alloc), 154 NULL, NFSLOG_SMALL_REC_NAME }, 155 #define MEDIUM_INDX 1 156 { NFSLOG_MEDIUM_RECORD_SIZE - sizeof (struct lr_alloc), 157 NULL, NFSLOG_MEDIUM_REC_NAME }, 158 #define LARGE_INDX 2 159 { NFSLOG_LARGE_RECORD_SIZE - sizeof (struct lr_alloc), 160 NULL, NFSLOG_LARGE_REC_NAME }, 161 { (-1), NULL } 162 }; 163 164 /* Used to calculate the 'real' allocation size */ 165 #define ALLOC_SIZE(index) \ 166 (nfslog_mem_alloc[index].size + sizeof (struct lr_alloc)) 167 168 /* 169 * Initialize logging data buffer cache 170 */ 171 void 172 nfslog_init() 173 { 174 int indx; 175 176 rw_init(&nfslog_buffer_list_lock, NULL, RW_DEFAULT, NULL); 177 178 /* 179 * Initialize the kmem caches for encoding 180 */ 181 for (indx = 0; nfslog_mem_alloc[indx].size != (-1); indx++) { 182 nfslog_mem_alloc[indx].mem_cache = 183 kmem_cache_create(nfslog_mem_alloc[indx].cache_name, 184 ALLOC_SIZE(indx), 0, NULL, NULL, NULL, NULL, NULL, 0); 185 } 186 } 187 188 /* 189 * Sets up the necessary log file and related buffers to enable logging 190 * on the given export point. 191 * Returns 0 on success, non-zero on failure. 192 */ 193 int 194 nfslog_setup(struct exportinfo *exi) 195 { 196 struct exportdata *kex; 197 struct log_buffer *lbp; 198 struct log_buffer *nlbp; 199 200 kex = &exi->exi_export; 201 ASSERT(kex->ex_flags & EX_LOG); 202 203 /* 204 * Logging is enabled for the new export point, check 205 * the existing log_buffer structures to see if the 206 * desired buffer has already been opened. If so, point 207 * the new exportinfo's exi_logbuffer to the existing 208 * one. 209 */ 210 rw_enter(&nfslog_buffer_list_lock, RW_READER); 211 for (lbp = nfslog_buffer_list; lbp != NULL; lbp = lbp->lb_next) { 212 LOGGING_DPRINT((10, 213 "searching for buffer... found log_buffer '%s'\n", 214 lbp->lb_path)); 215 if (strcmp(lbp->lb_path, kex->ex_log_buffer) == 0) { 216 /* Found our match. Ref it and return */ 217 LOG_BUFFER_HOLD(lbp); 218 exi->exi_logbuffer = lbp; 219 LOGGING_DPRINT((10, "\tfound log_buffer for '%s'\n", 220 kex->ex_log_buffer)); 221 rw_exit(&nfslog_buffer_list_lock); 222 return (0); 223 } 224 } 225 rw_exit(&nfslog_buffer_list_lock); 226 227 /* 228 * New buffer needed, allocate it. 229 * The buffer list lock has been dropped so we will need to search 230 * the list again to ensure that another thread has not added 231 * a matching buffer. 232 */ 233 if ((nlbp = log_buffer_create(kex->ex_log_buffer)) == NULL) { 234 /* 235 * Failed the buffer creation for some reason so we 236 * will need to return. 237 */ 238 return (EIO); 239 } 240 241 rw_enter(&nfslog_buffer_list_lock, RW_WRITER); 242 for (lbp = nfslog_buffer_list; lbp != NULL; 243 lbp = lbp->lb_next) { 244 if (strcmp(lbp->lb_path, kex->ex_log_buffer) == 0) { 245 /* 246 * A log_buffer already exists for the 247 * indicated buffer, use it instead. 248 */ 249 LOG_BUFFER_HOLD(lbp); 250 251 exi->exi_logbuffer = lbp; 252 253 LOGGING_DPRINT((10, "found log_buffer for '%s' " 254 "after allocation\n", kex->ex_log_buffer)); 255 256 rw_exit(&nfslog_buffer_list_lock); 257 258 log_buffer_rele(nlbp); 259 260 return (0); 261 } 262 } 263 /* 264 * Didn't find an existing log_buffer for this buffer, 265 * use the the newly created one, and add to list. We 266 * increment the reference count because the node is 267 * entered into the global list. 268 */ 269 LOGGING_DPRINT((10, "exportfs: adding nlbp=%p to list\n", 270 (void *)nlbp)); 271 272 nlbp->lb_next = nfslog_buffer_list; 273 nfslog_buffer_list = nlbp; 274 275 LOG_BUFFER_HOLD(nlbp); /* hold is for export entry */ 276 exi->exi_logbuffer = nlbp; 277 278 rw_exit(&nfslog_buffer_list_lock); 279 280 return (0); 281 } 282 283 /* 284 * Disables logging for the given export point. 285 */ 286 void 287 nfslog_disable(struct exportinfo *exi) 288 { 289 log_buffer_rele(exi->exi_logbuffer); 290 } 291 292 /* 293 * Creates the corresponding log_buffer and log_file structures 294 * for the the buffer named 'name'. 295 * Returns a pointer to the log_buffer structure with reference one. 296 */ 297 static struct log_buffer * 298 log_buffer_create(caddr_t name) 299 { 300 struct log_buffer *buffer; 301 struct log_file *logfile; 302 int namelen = strlen(name); 303 304 LOGGING_DPRINT((10, "log_buffer_create: %s\n", name)); 305 if (log_file_create(name, &logfile)) 306 return (NULL); 307 308 buffer = (struct log_buffer *)kmem_alloc(sizeof (*buffer), KM_SLEEP); 309 buffer->lb_refcnt = 1; 310 buffer->lb_rec_id = 0; 311 buffer->lb_path = (caddr_t)kmem_alloc(namelen + 1, KM_SLEEP); 312 bcopy(name, buffer->lb_path, namelen + 1); 313 buffer->lb_logfile = logfile; 314 buffer->lb_records = NULL; 315 buffer->lb_num_recs = 0; 316 buffer->lb_size_queued = 0; 317 mutex_init(&buffer->lb_lock, NULL, MUTEX_DEFAULT, NULL); 318 rfsl_log_buffer++; 319 320 return (buffer); 321 } 322 323 /* 324 * Release a log_buffer structure 325 */ 326 static void 327 log_buffer_rele(struct log_buffer *lbp) 328 { 329 int len; 330 331 mutex_enter(&lbp->lb_lock); 332 if (--lbp->lb_refcnt > 1) { 333 mutex_exit(&lbp->lb_lock); 334 return; 335 } 336 337 if (lbp->lb_refcnt < 0) { 338 panic("log_rele: log_buffer refcnt < 0"); 339 /*NOTREACHED*/ 340 } 341 342 /* 343 * Need to drop the lb_lock before acquiring the 344 * nfslog_buffer_list_lock. To avoid double free we need 345 * to hold an additional reference to the log buffer. 346 * This will ensure that no two threads will simultaneously 347 * be trying to free the same log buffer. 348 */ 349 350 if (lbp->lb_refcnt == 1) { 351 352 /* 353 * If the ref count is 1, then the last 354 * unshare/reference has been given up and we need to 355 * clean up the buffer and remove it from the buffer 356 * list. 357 */ 358 LOGGING_DPRINT((10, 359 "log_buffer_rele lbp=%p disconnecting\n", (void *)lbp)); 360 /* 361 * Hold additional reference before dropping the lb_lock 362 */ 363 364 lbp->lb_refcnt++; 365 mutex_exit(&lbp->lb_lock); 366 367 /* 368 * Make sure that all of the buffered records are written. 369 * Don't bother checking the write return value since there 370 * isn't much we can do at this point. 371 */ 372 (void) nfslog_records_flush_to_disk(lbp); 373 374 rw_enter(&nfslog_buffer_list_lock, RW_WRITER); 375 mutex_enter(&lbp->lb_lock); 376 /* 377 * Drop the reference count held above. 378 * If the ref count is still > 1 then someone has 379 * stepped in to use this log buffer. unlock and return. 380 */ 381 if (--lbp->lb_refcnt > 1) { 382 mutex_exit(&lbp->lb_lock); 383 rw_exit(&nfslog_buffer_list_lock); 384 return; 385 } 386 387 if (lbp == nfslog_buffer_list) { 388 nfslog_buffer_list = lbp->lb_next; 389 } else { 390 struct log_buffer *tlbp; 391 392 /* Drop the log_buffer from the master list */ 393 for (tlbp = nfslog_buffer_list; tlbp->lb_next != NULL; 394 tlbp = tlbp->lb_next) { 395 if (tlbp->lb_next == lbp) { 396 tlbp->lb_next = lbp->lb_next; 397 break; 398 } 399 } 400 } 401 402 mutex_exit(&lbp->lb_lock); 403 rw_exit(&nfslog_buffer_list_lock); 404 } 405 /* 406 * ref count zero; finish clean up. 407 */ 408 LOGGING_DPRINT((10, "log_buffer_rele lbp=%p freeing\n", (void *)lbp)); 409 410 log_file_rele(lbp->lb_logfile); 411 len = strlen(lbp->lb_path) + 1; 412 kmem_free(lbp->lb_path, len); 413 kmem_free(lbp, sizeof (*lbp)); 414 rfsl_log_buffer--; 415 } 416 417 /* 418 * Creates the corresponding log_file structure for the buffer 419 * named 'log_file_name'. 420 * 'log_file_name' is created by concatenating 'origname' and LOG_INPROG_STRING. 421 * 'logfile' is set to be the log_file structure with reference one. 422 */ 423 static int 424 log_file_create(caddr_t origname, struct log_file **lfpp) 425 { 426 vnode_t *vp = NULL; 427 char *name; 428 int namelen; 429 int error; 430 struct log_file *logfile = NULL; 431 vattr_t va; 432 caddr_t loghdr = NULL; 433 size_t loghdr_len = 0; 434 size_t loghdr_free = 0; 435 436 namelen = strlen(origname) + strlen(LOG_INPROG_STRING); 437 name = (caddr_t)kmem_alloc(namelen + 1, KM_SLEEP); 438 (void) sprintf(name, "%s%s", origname, LOG_INPROG_STRING); 439 440 LOGGING_DPRINT((3, "log_file_create: %s\n", name)); 441 if (error = vn_open(name, UIO_SYSSPACE, FCREAT|FWRITE|FOFFMAX, 442 LOG_MODE, &vp, CRCREAT, 0)) { 443 nfs_cmn_err(error, CE_WARN, 444 "log_file_create: Can not open %s - error %m", name); 445 goto out; 446 } 447 LOGGING_DPRINT((3, "log_file_create: %s vp=%p v_count=%d\n", 448 name, (void *)vp, vp->v_count)); 449 450 logfile = (struct log_file *)kmem_zalloc(sizeof (*logfile), KM_SLEEP); 451 logfile->lf_path = name; 452 /* 453 * No need to bump the vnode reference count since it is set 454 * to one by vn_open(). 455 */ 456 logfile->lf_vp = vp; 457 logfile->lf_refcnt = 1; 458 mutex_init(&logfile->lf_lock, NULL, MUTEX_DEFAULT, NULL); 459 rfsl_log_file++; 460 461 va.va_mask = AT_SIZE; 462 error = VOP_GETATTR(vp, &va, 0, CRED(), NULL); 463 if (error) { 464 nfs_cmn_err(error, CE_WARN, 465 "log_file_create: Can not stat %s - error = %m", name); 466 goto out; 467 } 468 469 if (va.va_size == 0) { 470 struct lr_alloc lr; 471 472 /* 473 * Write Header. 474 */ 475 create_buffer_header(&loghdr, &loghdr_len, &loghdr_free); 476 /* 477 * Dummy up a lr_alloc struct for the write 478 */ 479 lr.next = lr.prev = &lr; 480 lr.lr_flags = 0; 481 lr.log_record = loghdr; 482 lr.size = loghdr_len; 483 lr.alloc_cache = NULL; 484 lr.exi = NULL; 485 lr.lb = NULL; 486 487 mutex_enter(&logfile->lf_lock); 488 489 error = nfslog_write_logrecords(logfile, &lr, 1); 490 491 mutex_exit(&logfile->lf_lock); 492 493 if (error != 0) { 494 nfs_cmn_err(error, CE_WARN, 495 "log_file_create: Can not write header " 496 "on %s - error = %m", name); 497 goto out; 498 } 499 } 500 *lfpp = logfile; 501 502 if (loghdr != NULL) 503 kmem_free(loghdr, loghdr_free); 504 505 return (0); 506 507 out: 508 if (vp != NULL) { 509 int error1; 510 error1 = VOP_CLOSE(vp, FCREAT|FWRITE|FOFFMAX, 1, (offset_t)0, 511 CRED(), NULL); 512 if (error1) { 513 nfs_cmn_err(error1, CE_WARN, 514 "log_file_create: Can not close %s - " 515 "error = %m", name); 516 } 517 VN_RELE(vp); 518 } 519 520 kmem_free(name, namelen + 1); 521 if (logfile != NULL) { 522 mutex_destroy(&logfile->lf_lock); 523 kmem_free(logfile, sizeof (*logfile)); 524 rfsl_log_file--; 525 } 526 if (loghdr != NULL) 527 kmem_free(loghdr, loghdr_free); 528 529 return (error); 530 } 531 532 /* 533 * Release a log_file structure 534 */ 535 static void 536 log_file_rele(struct log_file *lfp) 537 { 538 int len; 539 int error; 540 541 mutex_enter(&lfp->lf_lock); 542 if (--lfp->lf_refcnt > 0) { 543 LOGGING_DPRINT((10, 544 "log_file_rele lfp=%p decremented refcnt to %d\n", 545 (void *)lfp, lfp->lf_refcnt)); 546 mutex_exit(&lfp->lf_lock); 547 return; 548 } 549 if (lfp->lf_refcnt < 0) { 550 panic("log_file_rele: log_file refcnt < 0"); 551 /*NOTREACHED*/ 552 } 553 554 LOGGING_DPRINT((10, "log_file_rele lfp=%p freeing node\n", 555 (void *)lfp)); 556 557 lfp->lf_flags &= ~(L_PRINTED | L_ERROR); 558 559 ASSERT(lfp->lf_flags == 0); 560 ASSERT(lfp->lf_writers == 0); 561 562 if (error = VOP_CLOSE(lfp->lf_vp, FCREAT|FWRITE|FOFFMAX, 1, (offset_t)0, 563 CRED(), NULL)) { 564 nfs_cmn_err(error, CE_WARN, 565 "NFS: Could not close log buffer %s - error = %m", 566 lfp->lf_path); 567 #ifdef DEBUG 568 } else { 569 LOGGING_DPRINT((3, 570 "log_file_rele: %s has been closed vp=%p v_count=%d\n", 571 lfp->lf_path, (void *)lfp->lf_vp, lfp->lf_vp->v_count)); 572 #endif 573 } 574 VN_RELE(lfp->lf_vp); 575 576 len = strlen(lfp->lf_path) + 1; 577 kmem_free(lfp->lf_path, len); 578 kmem_free(lfp, sizeof (*lfp)); 579 rfsl_log_file--; 580 } 581 582 /* 583 * Allocates a record of the size specified. 584 * 'exi' identifies the exportinfo structure being logged. 585 * 'size' indicates how much memory should be allocated 586 * 'cookie' is used to store an opaque value for the caller for later use 587 * 'flags' currently ignored. 588 * 589 * Returns a pointer to the beginning of the allocated memory. 590 * 'cookie' is a pointer to the 'lr_alloc' struct; this will be used 591 * to keep track of the encoded record and contains all the info 592 * for enqueuing the record on the log buffer for later writing. 593 * 594 * nfslog_record_put() must be used to 'free' this record or allocation. 595 */ 596 /* ARGSUSED */ 597 void * 598 nfslog_record_alloc( 599 struct exportinfo *exi, 600 int alloc_indx, 601 void **cookie, 602 int flags) 603 { 604 struct lr_alloc *lrp; 605 606 lrp = (struct lr_alloc *) 607 kmem_cache_alloc(nfslog_mem_alloc[alloc_indx].mem_cache, 608 KM_NOSLEEP); 609 610 if (lrp == NULL) { 611 *cookie = NULL; 612 return (NULL); 613 } 614 615 lrp->next = lrp; 616 lrp->prev = lrp; 617 lrp->lr_flags = 0; 618 619 lrp->log_record = (caddr_t)((uintptr_t)lrp + 620 (uintptr_t)sizeof (struct lr_alloc)); 621 lrp->size = nfslog_mem_alloc[alloc_indx].size; 622 lrp->alloc_cache = nfslog_mem_alloc[alloc_indx].mem_cache; 623 lrp->exi = exi; 624 625 if (exi->exi_export.ex_flags & EX_LOG) { 626 LOG_BUFFER_HOLD(exi->exi_logbuffer); 627 lrp->lb = exi->exi_logbuffer; 628 } else { 629 lrp->lb = NULL; 630 } 631 632 *cookie = (void *)lrp; 633 634 LOGGING_DPRINT((3, 635 "nfslog_record_alloc(log_buffer=%p mem=%p size=%lu)\n", 636 (void *)exi->exi_logbuffer, (void *)lrp->log_record, lrp->size)); 637 return (lrp->log_record); 638 } 639 640 /* 641 * After the above nfslog_record_alloc() has been called and a record 642 * encoded into the buffer that was returned, this function is called 643 * to handle appropriate disposition of the newly created record. 644 * The cookie value is the one that was returned from nfslog_record_alloc(). 645 * Size is the actual size of the record that was encoded. This is 646 * passed in because the size used for the alloc was just an approximation. 647 * The sync parameter is used to tell us if we need to force this record 648 * to disk and if not it will be queued for later writing. 649 * 650 * Note that if the size parameter has a value of 0, then the record is 651 * not written to the log and the associated data structures are released. 652 */ 653 void 654 nfslog_record_put(void *cookie, size_t size, bool_t sync, 655 unsigned int which_buffers) 656 { 657 struct lr_alloc *lrp = (struct lr_alloc *)cookie; 658 struct log_buffer *lbp = lrp->lb; 659 660 /* 661 * If the caller has nothing to write or if there is 662 * an apparent error, rele the buffer and free. 663 */ 664 if (size == 0 || size > lrp->size) { 665 nfslog_free_logrecords(lrp); 666 return; 667 } 668 669 /* 670 * Reset the size to what actually needs to be written 671 * This is used later on when the iovec is built for 672 * writing the records to the log file. 673 */ 674 lrp->size = size; 675 676 /* append to all if public exi */ 677 if (which_buffers == NFSLOG_ALL_BUFFERS) { 678 (void) nfslog_record_append2all(lrp); 679 nfslog_free_logrecords(lrp); 680 return; 681 } 682 683 /* Insert the record on the list to be written */ 684 mutex_enter(&lbp->lb_lock); 685 if (lbp->lb_records == NULL) { 686 lbp->lb_records = (caddr_t)lrp; 687 lbp->lb_num_recs = 1; 688 lbp->lb_size_queued = lrp->size; 689 } else { 690 insque(lrp, ((struct lr_alloc *)lbp->lb_records)->prev); 691 lbp->lb_num_recs++; 692 lbp->lb_size_queued += lrp->size; 693 } 694 695 /* 696 * Determine if the queue for this log buffer should be flushed. 697 * This is done by either the number of records queued, the total 698 * size of all records queued or by the request of the caller 699 * via the sync parameter. 700 */ 701 if (lbp->lb_size_queued >= nfslog_num_bytes_to_write || 702 lbp->lb_num_recs > nfslog_num_records_to_write || sync == TRUE) { 703 mutex_exit(&lbp->lb_lock); 704 (void) nfslog_records_flush_to_disk(lbp); 705 } else { 706 mutex_exit(&lbp->lb_lock); 707 } 708 709 } 710 711 /* 712 * Examine the log_buffer struct to see if there are queue log records 713 * that need to be written to disk. If some exist, pull them off of 714 * the log buffer and write them to the log file. 715 */ 716 static int 717 nfslog_records_flush_to_disk(struct log_buffer *lbp) 718 { 719 720 mutex_enter(&lbp->lb_lock); 721 722 if (lbp->lb_records == NULL) { 723 mutex_exit(&lbp->lb_lock); 724 return (0); 725 } 726 return (nfslog_records_flush_to_disk_nolock(lbp)); 727 } 728 729 /* 730 * Function requires that the caller holds lb_lock. 731 * Function flushes any records in the log buffer to the disk. 732 * Function drops the lb_lock on return. 733 */ 734 735 static int 736 nfslog_records_flush_to_disk_nolock(struct log_buffer *lbp) 737 { 738 struct log_file *lfp = NULL; 739 struct lr_alloc *lrp_writers; 740 int num_recs; 741 int error = 0; 742 743 ASSERT(MUTEX_HELD(&lbp->lb_lock)); 744 745 lfp = lbp->lb_logfile; 746 747 LOG_FILE_LOCK_TO_WRITE(lfp); 748 ASSERT(lbp->lb_records != NULL); 749 750 lrp_writers = (struct lr_alloc *)lbp->lb_records; 751 lbp->lb_records = NULL; 752 num_recs = lbp->lb_num_recs; 753 lbp->lb_num_recs = 0; 754 lbp->lb_size_queued = 0; 755 mutex_exit(&lbp->lb_lock); 756 error = nfslog_write_logrecords(lfp, lrp_writers, num_recs); 757 758 LOG_FILE_UNLOCK_FROM_WRITE(lfp); 759 760 nfslog_free_logrecords(lrp_writers); 761 return (error); 762 } 763 764 765 /* 766 * Take care of writing the provided log record(s) to the log file. 767 * We group the log records with an iovec and use VOP_WRITE to append 768 * them to the end of the log file. 769 */ 770 static int 771 nfslog_write_logrecords(struct log_file *lfp, struct lr_alloc *lrp_writers, 772 int num_recs) 773 { 774 struct uio uio; 775 struct iovec *iovp; 776 int size_iovecs; 777 vnode_t *vp; 778 struct vattr va; 779 struct lr_alloc *lrp; 780 int i; 781 ssize_t len; 782 int ioflag = FAPPEND; 783 int error = 0; 784 785 ASSERT(MUTEX_HELD(&lfp->lf_lock)); 786 787 vp = lfp->lf_vp; 788 789 size_iovecs = sizeof (struct iovec) * num_recs; 790 iovp = (struct iovec *)kmem_alloc(size_iovecs, KM_NOSLEEP); 791 792 if (iovp == NULL) { 793 error = ENOMEM; 794 goto out; 795 } 796 797 /* Build the iovec based on the list of log records */ 798 i = 0; 799 len = 0; 800 lrp = lrp_writers; 801 do { 802 iovp[i].iov_base = lrp->log_record; 803 iovp[i].iov_len = lrp->size; 804 len += lrp->size; 805 lrp = lrp->next; 806 i++; 807 } while (lrp != lrp_writers); 808 809 ASSERT(i == num_recs); 810 811 uio.uio_iov = iovp; 812 uio.uio_iovcnt = num_recs; 813 uio.uio_loffset = 0; 814 uio.uio_segflg = (short)UIO_SYSSPACE; 815 uio.uio_resid = len; 816 uio.uio_llimit = (rlim64_t)MAXOFFSET_T; 817 uio.uio_fmode = FWRITE; 818 uio.uio_extflg = UIO_COPY_DEFAULT; 819 820 /* 821 * Save the size. If the write fails, reset the size to avoid 822 * corrupted log buffer files. 823 */ 824 va.va_mask = AT_SIZE; 825 826 (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL); /* UIO_WRITE */ 827 if ((error = VOP_GETATTR(vp, &va, 0, CRED(), NULL)) == 0) { 828 if ((len + va.va_size) < (MAXOFF32_T)) { 829 error = VOP_WRITE(vp, &uio, ioflag, CRED(), NULL); 830 VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 831 if (uio.uio_resid) 832 error = ENOSPC; 833 if (error) 834 (void) VOP_SETATTR(vp, &va, 0, CRED(), NULL); 835 } else { 836 VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 837 if (!(lfp->lf_flags & L_PRINTED)) { 838 cmn_err(CE_WARN, 839 "NFS Logging: buffer file %s exceeds 2GB; " 840 "stopped writing buffer \n", lfp->lf_path); 841 } 842 error = ENOSPC; 843 } 844 } else { 845 VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 846 } 847 848 kmem_free(iovp, size_iovecs); 849 850 out: 851 if (error) { 852 if (!(lfp->lf_flags & L_PRINTED)) { 853 nfs_cmn_err(error, CE_WARN, 854 "NFS Logging disabled for buffer %s - " 855 "write error = %m\n", lfp->lf_path); 856 lfp->lf_flags |= L_PRINTED; 857 } 858 } else if (lfp->lf_flags & (L_ERROR | L_PRINTED)) { 859 lfp->lf_flags &= ~(L_ERROR | L_PRINTED); 860 cmn_err(CE_WARN, 861 "NFS Logging re-enabled for buffer %s\n", lfp->lf_path); 862 } 863 864 return (error); 865 } 866 867 static void 868 nfslog_free_logrecords(struct lr_alloc *lrp_writers) 869 { 870 struct lr_alloc *lrp = lrp_writers; 871 struct lr_alloc *lrp_free; 872 873 do { 874 lrp_free = lrp; 875 876 lrp = lrp->next; 877 878 /* 879 * Check to see if we are supposed to free this structure 880 * and relese the log_buffer ref count. 881 * It may be the case that the caller does not want this 882 * structure and its record contents freed just yet. 883 */ 884 if ((lrp_free->lr_flags & LR_ALLOC_NOFREE) == 0) { 885 if (lrp_free->lb != NULL) 886 log_buffer_rele(lrp_free->lb); 887 if (lrp_free->alloc_cache) /* double check */ 888 kmem_cache_free(lrp_free->alloc_cache, 889 (void *)lrp_free); 890 } else { 891 /* 892 * after being pulled from the list the 893 * pointers need to be reinitialized. 894 */ 895 lrp_free->next = lrp_free; 896 lrp_free->prev = lrp_free; 897 } 898 899 } while (lrp != lrp_writers); 900 } 901 902 /* 903 * Rename lbp->lb_logfile to reflect the true name requested by 'share' 904 */ 905 static int 906 nfslog_logbuffer_rename(struct log_buffer *lbp) 907 { 908 struct log_file *lf; 909 int error; 910 struct log_file *logfile; 911 912 /* 913 * Try our best to get the cache records into the log file 914 * before the rename occurs. 915 */ 916 (void) nfslog_records_flush_to_disk(lbp); 917 918 /* 919 * Hold lb_lock before retrieving 920 * lb_logfile. 921 * Hold a reference to the 922 * "lf" structure. this is 923 * same as LOG_FILE_HOLD() 924 */ 925 mutex_enter(&(lbp)->lb_lock); 926 lf = lbp->lb_logfile; 927 mutex_enter(&(lf)->lf_lock); 928 mutex_exit(&(lbp)->lb_lock); 929 lf->lf_refcnt++; 930 mutex_exit(&(lf)->lf_lock); 931 932 LOGGING_DPRINT((10, "nfslog_logbuffer_rename: renaming %s to %s\n", 933 lf->lf_path, lbp->lb_path)); 934 935 /* 936 * rename the current buffer to what the daemon expects 937 */ 938 if (error = nfslog_logfile_rename(lf->lf_path, lbp->lb_path)) 939 goto out; 940 941 /* 942 * Create a new working buffer file and have all new data sent there. 943 */ 944 if (error = log_file_create(lbp->lb_path, &logfile)) { 945 /* Attempt to rename to original */ 946 (void) nfslog_logfile_rename(lbp->lb_path, lf->lf_path); 947 goto out; 948 } 949 950 /* 951 * Hold the lb_lock here, this will make 952 * all the threads trying to access lb->logfile block 953 * and get a new logfile structure instead of old one. 954 */ 955 mutex_enter(&(lbp)->lb_lock); 956 lbp->lb_logfile = logfile; 957 mutex_exit(&(lbp)->lb_lock); 958 959 LOG_FILE_RELE(lf); /* release log_buffer's reference */ 960 961 /* 962 * Wait for log_file to be in a quiescent state before we 963 * return to our caller to let it proceed with the reading of 964 * this file. 965 */ 966 nfslog_logfile_wait(lf); 967 968 out: 969 /* 970 * Release our reference on "lf" in two different cases. 971 * 1. Error condition, release only the reference 972 * that we held at the begining of this 973 * routine on "lf" structure. 974 * 2. Fall through condition, no errors but the old 975 * logfile structure "lf" has been replaced with 976 * the new "logfile" structure, so release the 977 * reference that was part of the creation of 978 * "lf" structure to free up the resources. 979 */ 980 981 LOG_FILE_RELE(lf); 982 983 return (error); 984 } 985 986 /* 987 * Renames the 'from' file to 'new'. 988 */ 989 static int 990 nfslog_logfile_rename(char *from, char *new) 991 { 992 int error; 993 994 if (error = vn_rename(from, new, UIO_SYSSPACE)) { 995 cmn_err(CE_WARN, 996 "nfslog_logfile_rename: couldn't rename %s to %s\n", 997 from, new); 998 } 999 return (error); 1000 } 1001 1002 /* 1003 * Wait for the log_file writers to finish before returning 1004 */ 1005 static void 1006 nfslog_logfile_wait(struct log_file *lf) 1007 { 1008 mutex_enter(&lf->lf_lock); 1009 while (lf->lf_writers > 0) { 1010 lf->lf_flags |= L_WAITING; 1011 (void) cv_wait_sig(&lf->lf_cv_waiters, &lf->lf_lock); 1012 } 1013 mutex_exit(&lf->lf_lock); 1014 } 1015 1016 static int 1017 nfslog_record_append2all(struct lr_alloc *lrp) 1018 { 1019 struct log_buffer *lbp, *nlbp; 1020 int error, ret_error = 0; 1021 int lr_flags = lrp->lr_flags; 1022 1023 rw_enter(&nfslog_buffer_list_lock, RW_READER); 1024 if ((lbp = nfslog_buffer_list) != NULL) 1025 LOG_BUFFER_HOLD(lbp); 1026 for (nlbp = NULL; lbp != NULL; lbp = nlbp) { 1027 if ((nlbp = lbp->lb_next) != NULL) { 1028 /* 1029 * Remember next element in the list 1030 */ 1031 LOG_BUFFER_HOLD(nlbp); 1032 } 1033 rw_exit(&nfslog_buffer_list_lock); 1034 1035 /* 1036 * Insert the record on the buffer's list to be written 1037 * and then flush the records to the log file. 1038 * Make sure to set the no free flag so that the 1039 * record can be used for the next write 1040 */ 1041 lrp->lr_flags = LR_ALLOC_NOFREE; 1042 1043 ASSERT(lbp != NULL); 1044 mutex_enter(&lbp->lb_lock); 1045 if (lbp->lb_records == NULL) { 1046 lbp->lb_records = (caddr_t)lrp; 1047 lbp->lb_num_recs = 1; 1048 lbp->lb_size_queued = lrp->size; 1049 } else { 1050 insque(lrp, ((struct lr_alloc *)lbp->lb_records)->prev); 1051 lbp->lb_num_recs++; 1052 lbp->lb_size_queued += lrp->size; 1053 } 1054 1055 /* 1056 * Flush log records to disk. 1057 * Function is called with lb_lock held. 1058 * Function drops the lb_lock on return. 1059 */ 1060 error = nfslog_records_flush_to_disk_nolock(lbp); 1061 1062 if (error) { 1063 ret_error = -1; 1064 nfs_cmn_err(error, CE_WARN, 1065 "rfsl_log_pubfh: could not append record to " 1066 "\"%s\" error = %m\n", lbp->lb_path); 1067 } 1068 log_buffer_rele(lbp); 1069 rw_enter(&nfslog_buffer_list_lock, RW_READER); 1070 } 1071 rw_exit(&nfslog_buffer_list_lock); 1072 1073 lrp->lr_flags = lr_flags; 1074 1075 return (ret_error); 1076 } 1077 1078 #ifdef DEBUG 1079 static int logging_debug = 0; 1080 1081 /* 1082 * 0) no debugging 1083 * 3) current test software 1084 * 10) random stuff 1085 */ 1086 void 1087 nfslog_dprint(const int level, const char *fmt, ...) 1088 { 1089 va_list args; 1090 1091 if (logging_debug == level || 1092 (logging_debug > 10 && (logging_debug - 10) >= level)) { 1093 va_start(args, fmt); 1094 (void) vprintf(fmt, args); 1095 va_end(args); 1096 } 1097 } 1098 1099 #endif /* DEBUG */ 1100 1101 /* 1102 * NFS Log Flush system call 1103 * Caller must check privileges. 1104 */ 1105 /* ARGSUSED */ 1106 int 1107 nfsl_flush(struct nfsl_flush_args *args, model_t model) 1108 { 1109 struct flush_thread_params *tparams; 1110 struct nfsl_flush_args *nfsl_args; 1111 int error = 0; 1112 ulong_t buffer_len; 1113 STRUCT_HANDLE(nfsl_flush_args, uap); 1114 1115 STRUCT_SET_HANDLE(uap, model, args); 1116 1117 tparams = (struct flush_thread_params *) 1118 kmem_zalloc(sizeof (*tparams), KM_SLEEP); 1119 1120 nfsl_args = &tparams->tp_args; 1121 nfsl_args->version = STRUCT_FGET(uap, version); 1122 if (nfsl_args->version != NFSL_FLUSH_ARGS_VERS) { 1123 cmn_err(CE_WARN, "nfsl_flush: exected version %d, got %d", 1124 NFSL_FLUSH_ARGS_VERS, nfsl_args->version); 1125 return (EIO); 1126 } 1127 1128 nfsl_args->directive = STRUCT_FGET(uap, directive); 1129 if ((nfsl_args->directive & NFSL_ALL) == 0) { 1130 /* 1131 * Process a specific buffer 1132 */ 1133 nfsl_args->buff_len = STRUCT_FGET(uap, buff_len); 1134 1135 nfsl_args->buff = (char *) 1136 kmem_alloc(nfsl_args->buff_len, KM_NOSLEEP); 1137 if (nfsl_args->buff == NULL) 1138 return (ENOMEM); 1139 1140 error = copyinstr((const char *)STRUCT_FGETP(uap, buff), 1141 nfsl_args->buff, nfsl_args->buff_len, &buffer_len); 1142 if (error) 1143 return (EFAULT); 1144 1145 if (nfsl_args->buff_len != buffer_len) 1146 return (EFAULT); 1147 } 1148 1149 LOGGING_DPRINT((10, "nfsl_flush: Flushing %s buffer(s)\n", 1150 nfsl_args->directive & NFSL_ALL ? "all" : nfsl_args->buff)); 1151 1152 if (nfsl_args->directive & NFSL_SYNC) { 1153 /* 1154 * Do the work synchronously 1155 */ 1156 nfslog_do_flush(tparams); 1157 error = tparams->tp_error; 1158 kmem_free(nfsl_args->buff, nfsl_args->buff_len); 1159 kmem_free(tparams, sizeof (*tparams)); 1160 } else { 1161 /* 1162 * Do the work asynchronously 1163 */ 1164 (void) thread_create(NULL, 0, nfslog_do_flush, 1165 tparams, 0, &p0, TS_RUN, minclsyspri); 1166 } 1167 1168 return (error); 1169 } 1170 1171 /* 1172 * This is where buffer flushing would occur, but there is no buffering 1173 * at this time. 1174 * Possibly rename the log buffer for processing. 1175 * Sets tparams->ta_error equal to the value of the error that occurred, 1176 * 0 otherwise. 1177 * Returns ENOENT if the buffer is not found. 1178 */ 1179 static void 1180 nfslog_do_flush(struct flush_thread_params *tparams) 1181 { 1182 struct nfsl_flush_args *args; 1183 struct log_buffer *lbp, *nlbp; 1184 int error = ENOENT; 1185 int found = 0; 1186 char *buf_inprog; /* name of buff in progress */ 1187 int buf_inprog_len; 1188 1189 /* 1190 * Sanity check on the arguments. 1191 */ 1192 if (!tparams) 1193 return; 1194 args = &tparams->tp_args; 1195 if (!args) 1196 return; 1197 1198 rw_enter(&nfslog_buffer_list_lock, RW_READER); 1199 if ((lbp = nfslog_buffer_list) != NULL) { 1200 LOG_BUFFER_HOLD(lbp); 1201 } 1202 for (nlbp = NULL; lbp != NULL; lbp = nlbp) { 1203 if ((nlbp = lbp->lb_next) != NULL) { 1204 LOG_BUFFER_HOLD(nlbp); 1205 } 1206 rw_exit(&nfslog_buffer_list_lock); 1207 if (args->directive & NFSL_ALL) { 1208 (void) nfslog_records_flush_to_disk(lbp); 1209 } else { 1210 if ((strcmp(lbp->lb_path, args->buff) == 0) && 1211 (args->directive & NFSL_RENAME)) { 1212 error = nfslog_logbuffer_rename(lbp); 1213 found++; 1214 if (nlbp != NULL) 1215 log_buffer_rele(nlbp); 1216 log_buffer_rele(lbp); 1217 break; 1218 } 1219 } 1220 log_buffer_rele(lbp); 1221 rw_enter(&nfslog_buffer_list_lock, RW_READER); 1222 } 1223 if (!found) 1224 rw_exit(&nfslog_buffer_list_lock); 1225 1226 if (!found && ((args->directive & NFSL_ALL) == 0) && 1227 (args->directive & NFSL_RENAME)) { 1228 /* 1229 * The specified buffer is not currently in use, 1230 * simply rename the file indicated. 1231 */ 1232 buf_inprog_len = strlen(args->buff) + 1233 strlen(LOG_INPROG_STRING) + 1; 1234 buf_inprog = (caddr_t)kmem_alloc(buf_inprog_len, KM_SLEEP); 1235 (void) sprintf(buf_inprog, "%s%s", 1236 args->buff, LOG_INPROG_STRING); 1237 1238 error = nfslog_logfile_rename(buf_inprog, args->buff); 1239 1240 kmem_free(buf_inprog, buf_inprog_len); 1241 } 1242 1243 out: 1244 if ((args->directive & NFSL_SYNC) == 0) { 1245 /* 1246 * Work was performed asynchronously, the caller is 1247 * no longer waiting for us. 1248 * Free the thread arguments and exit. 1249 */ 1250 kmem_free(args->buff, args->buff_len); 1251 kmem_free(tparams, sizeof (*tparams)); 1252 thread_exit(); 1253 /* NOTREACHED */ 1254 } 1255 1256 tparams->tp_error = error; 1257 } 1258 1259 /* 1260 * Generate buffer_header. 1261 * 'loghdr' points the the buffer_header, and *reclen 1262 * contains the length of the buffer. 1263 */ 1264 static void 1265 create_buffer_header(caddr_t *loghdr, size_t *reclen, size_t *freesize) 1266 { 1267 timestruc_t now; 1268 nfslog_buffer_header lh; 1269 XDR xdrs; 1270 unsigned int final_size; 1271 1272 1273 /* pick some size that will hold the buffer_header */ 1274 *freesize = NFSLOG_SMALL_RECORD_SIZE; 1275 1276 /* 1277 * Fill header 1278 */ 1279 lh.bh_length = 0; /* don't know yet how large it will be */ 1280 lh.bh_version = NFSLOG_BUF_VERSION; 1281 lh.bh_flags = 0; 1282 lh.bh_offset = 0; 1283 gethrestime(&now); 1284 TIMESPEC_TO_TIMESPEC32(&lh.bh_timestamp, &now); 1285 1286 /* 1287 * Encode the header 1288 */ 1289 *loghdr = (caddr_t)kmem_alloc(*freesize, KM_SLEEP); 1290 xdrmem_create(&xdrs, *loghdr, *freesize, XDR_ENCODE); 1291 1292 (void) xdr_nfslog_buffer_header(&xdrs, &lh); 1293 1294 /* 1295 * Reset with final size of the encoded data 1296 */ 1297 final_size = xdr_getpos(&xdrs); 1298 xdr_setpos(&xdrs, 0); 1299 (void) xdr_u_int(&xdrs, &final_size); 1300 1301 *reclen = (size_t)final_size; 1302 } 1303 1304 /* 1305 * **************************************************************** 1306 * RPC dispatch table for logging 1307 * Indexed by program, version, proc 1308 * Based on NFS dispatch table. 1309 */ 1310 struct nfslog_proc_disp { 1311 bool_t (*xdrargs)(); 1312 bool_t (*xdrres)(); 1313 bool_t affects_transactions; /* Operation affects transaction */ 1314 /* processing */ 1315 }; 1316 1317 struct nfslog_vers_disp { 1318 int nfslog_dis_nprocs; /* number of procs */ 1319 struct nfslog_proc_disp *nfslog_dis_proc_table; /* proc array */ 1320 }; 1321 1322 struct nfslog_prog_disp { 1323 int nfslog_dis_prog; /* program number */ 1324 int nfslog_dis_versmin; /* Minimum version value */ 1325 int nfslog_dis_nvers; /* Number of version values */ 1326 struct nfslog_vers_disp *nfslog_dis_vers_table; /* versions array */ 1327 }; 1328 1329 static int rfs_log_bad = 0; /* incremented on bad log attempts */ 1330 static int rfs_log_good = 0; /* incremented on successful log attempts */ 1331 1332 /* 1333 * Define the actions taken per prog/vers/proc: 1334 * 1335 * In some cases, the nl types are the same as the nfs types and a simple 1336 * bcopy should suffice. Rather that define tens of identical procedures, 1337 * simply define these to bcopy. Similarly this takes care of different 1338 * procs that use same parameter struct. 1339 */ 1340 1341 static struct nfslog_proc_disp nfslog_proc_v2[] = { 1342 /* 1343 * NFS VERSION 2 1344 */ 1345 1346 /* RFS_NULL = 0 */ 1347 {xdr_void, xdr_void, FALSE}, 1348 1349 /* RFS_GETATTR = 1 */ 1350 {xdr_fhandle, xdr_nfslog_getattrres, FALSE}, 1351 1352 /* RFS_SETATTR = 2 */ 1353 {xdr_nfslog_setattrargs, xdr_nfsstat, TRUE}, 1354 1355 /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */ 1356 {xdr_void, xdr_void, FALSE}, 1357 1358 /* RFS_LOOKUP = 4 */ 1359 {xdr_nfslog_diropargs, xdr_nfslog_diropres, TRUE}, 1360 1361 /* RFS_READLINK = 5 */ 1362 {xdr_fhandle, xdr_nfslog_rdlnres, FALSE}, 1363 1364 /* RFS_READ = 6 */ 1365 {xdr_nfslog_nfsreadargs, xdr_nfslog_rdresult, TRUE}, 1366 1367 /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */ 1368 {xdr_void, xdr_void, FALSE}, 1369 1370 /* RFS_WRITE = 8 */ 1371 {xdr_nfslog_writeargs, xdr_nfslog_writeresult, TRUE}, 1372 1373 /* RFS_CREATE = 9 */ 1374 {xdr_nfslog_createargs, xdr_nfslog_diropres, TRUE}, 1375 1376 /* RFS_REMOVE = 10 */ 1377 {xdr_nfslog_diropargs, xdr_nfsstat, TRUE}, 1378 1379 /* RFS_RENAME = 11 */ 1380 {xdr_nfslog_rnmargs, xdr_nfsstat, TRUE}, 1381 1382 /* RFS_LINK = 12 */ 1383 {xdr_nfslog_linkargs, xdr_nfsstat, TRUE}, 1384 1385 /* RFS_SYMLINK = 13 */ 1386 {xdr_nfslog_symlinkargs, xdr_nfsstat, TRUE}, 1387 1388 /* RFS_MKDIR = 14 */ 1389 {xdr_nfslog_createargs, xdr_nfslog_diropres, TRUE}, 1390 1391 /* RFS_RMDIR = 15 */ 1392 {xdr_nfslog_diropargs, xdr_nfsstat, TRUE}, 1393 1394 /* RFS_READDIR = 16 */ 1395 {xdr_nfslog_rddirargs, xdr_nfslog_rddirres, TRUE}, 1396 1397 /* RFS_STATFS = 17 */ 1398 {xdr_fhandle, xdr_nfslog_statfs, FALSE}, 1399 }; 1400 1401 1402 /* 1403 * NFS VERSION 3 1404 */ 1405 1406 static struct nfslog_proc_disp nfslog_proc_v3[] = { 1407 1408 /* NFSPROC3_NULL = 0 */ 1409 {xdr_void, xdr_void, FALSE}, 1410 1411 /* NFSPROC3_GETATTR = 1 */ 1412 {xdr_nfslog_nfs_fh3, xdr_nfslog_GETATTR3res, FALSE}, 1413 1414 /* NFSPROC3_SETATTR = 2 */ 1415 {xdr_nfslog_SETATTR3args, xdr_nfslog_SETATTR3res, TRUE}, 1416 1417 /* NFSPROC3_LOOKUP = 3 */ 1418 {xdr_nfslog_diropargs3, xdr_nfslog_LOOKUP3res, TRUE}, 1419 1420 /* NFSPROC3_ACCESS = 4 */ 1421 {xdr_nfslog_ACCESS3args, xdr_nfslog_ACCESS3res, FALSE}, 1422 1423 /* NFSPROC3_READLINK = 5 */ 1424 {xdr_nfslog_nfs_fh3, xdr_nfslog_READLINK3res, FALSE}, 1425 1426 /* NFSPROC3_READ = 6 */ 1427 {xdr_nfslog_READ3args, xdr_nfslog_READ3res, TRUE}, 1428 1429 /* NFSPROC3_WRITE = 7 */ 1430 {xdr_nfslog_WRITE3args, xdr_nfslog_WRITE3res, TRUE}, 1431 1432 /* NFSPROC3_CREATE = 8 */ 1433 {xdr_nfslog_CREATE3args, xdr_nfslog_CREATE3res, TRUE}, 1434 1435 /* NFSPROC3_MKDIR = 9 */ 1436 {xdr_nfslog_MKDIR3args, xdr_nfslog_MKDIR3res, TRUE}, 1437 1438 /* NFSPROC3_SYMLINK = 10 */ 1439 {xdr_nfslog_SYMLINK3args, xdr_nfslog_SYMLINK3res, TRUE}, 1440 1441 /* NFSPROC3_MKNOD = 11 */ 1442 {xdr_nfslog_MKNOD3args, xdr_nfslog_MKNOD3res, TRUE}, 1443 1444 /* NFSPROC3_REMOVE = 12 */ 1445 {xdr_nfslog_REMOVE3args, xdr_nfslog_REMOVE3res, TRUE}, 1446 1447 /* NFSPROC3_RMDIR = 13 */ 1448 {xdr_nfslog_RMDIR3args, xdr_nfslog_RMDIR3res, TRUE}, 1449 1450 /* NFSPROC3_RENAME = 14 */ 1451 {xdr_nfslog_RENAME3args, xdr_nfslog_RENAME3res, TRUE}, 1452 1453 /* NFSPROC3_LINK = 15 */ 1454 {xdr_nfslog_LINK3args, xdr_nfslog_LINK3res, TRUE}, 1455 1456 /* NFSPROC3_READDIR = 16 */ 1457 {xdr_nfslog_READDIR3args, xdr_nfslog_READDIR3res, TRUE}, 1458 1459 /* NFSPROC3_READDIRPLUS = 17 */ 1460 {xdr_nfslog_READDIRPLUS3args, xdr_nfslog_READDIRPLUS3res, TRUE}, 1461 1462 /* NFSPROC3_FSSTAT = 18 */ 1463 {xdr_nfslog_FSSTAT3args, xdr_nfslog_FSSTAT3res, FALSE}, 1464 1465 /* NFSPROC3_FSINFO = 19 */ 1466 {xdr_nfslog_FSINFO3args, xdr_nfslog_FSINFO3res, FALSE}, 1467 1468 /* NFSPROC3_PATHCONF = 20 */ 1469 {xdr_nfslog_PATHCONF3args, xdr_nfslog_PATHCONF3res, FALSE}, 1470 1471 /* NFSPROC3_COMMIT = 21 */ 1472 {xdr_nfslog_COMMIT3args, xdr_nfslog_COMMIT3res, FALSE}, 1473 }; 1474 1475 static struct nfslog_proc_disp nfslog_proc_v1[] = { 1476 /* 1477 * NFSLOG VERSION 1 1478 */ 1479 1480 /* NFSLOG_NULL = 0 */ 1481 {xdr_void, xdr_void, TRUE}, 1482 1483 /* NFSLOG_SHARE = 1 */ 1484 {xdr_nfslog_sharefsargs, xdr_nfslog_sharefsres, TRUE}, 1485 1486 /* NFSLOG_UNSHARE = 2 */ 1487 {xdr_nfslog_sharefsargs, xdr_nfslog_sharefsres, TRUE}, 1488 1489 /* NFSLOG_LOOKUP = 3 */ 1490 {xdr_nfslog_diropargs3, xdr_nfslog_LOOKUP3res, TRUE}, 1491 1492 /* NFSLOG_GETFH = 4 */ 1493 {xdr_nfslog_getfhargs, xdr_nfsstat, TRUE}, 1494 }; 1495 1496 static struct nfslog_vers_disp nfslog_vers_disptable[] = { 1497 {sizeof (nfslog_proc_v2) / sizeof (nfslog_proc_v2[0]), 1498 nfslog_proc_v2}, 1499 {sizeof (nfslog_proc_v3) / sizeof (nfslog_proc_v3[0]), 1500 nfslog_proc_v3}, 1501 }; 1502 1503 static struct nfslog_vers_disp nfslog_nfslog_vers_disptable[] = { 1504 {sizeof (nfslog_proc_v1) / sizeof (nfslog_proc_v1[0]), 1505 nfslog_proc_v1}, 1506 }; 1507 1508 static struct nfslog_prog_disp nfslog_dispatch_table[] = { 1509 {NFS_PROGRAM, NFS_VERSMIN, 1510 (sizeof (nfslog_vers_disptable) / 1511 sizeof (nfslog_vers_disptable[0])), 1512 nfslog_vers_disptable}, 1513 1514 {NFSLOG_PROGRAM, NFSLOG_VERSMIN, 1515 (sizeof (nfslog_nfslog_vers_disptable) / 1516 sizeof (nfslog_nfslog_vers_disptable[0])), 1517 nfslog_nfslog_vers_disptable}, 1518 }; 1519 1520 static int nfslog_dispatch_table_arglen = sizeof (nfslog_dispatch_table) / 1521 sizeof (nfslog_dispatch_table[0]); 1522 1523 /* 1524 * This function will determine the appropriate export info struct to use 1525 * and allocate a record id to be used in the written log buffer. 1526 * Usually this is a straightforward operation but the existence of the 1527 * multicomponent lookup and its semantics of crossing file system 1528 * boundaries add to the complexity. See the comments below... 1529 */ 1530 struct exportinfo * 1531 nfslog_get_exi( 1532 struct exportinfo *exi, 1533 struct svc_req *req, 1534 caddr_t res, 1535 unsigned int *nfslog_rec_id) 1536 { 1537 struct log_buffer *lb; 1538 struct exportinfo *exi_ret = NULL; 1539 fhandle_t *fh; 1540 nfs_fh3 *fh3; 1541 1542 if (exi == NULL) 1543 return (NULL); 1544 1545 /* 1546 * If the exi is marked for logging, allocate a record id and return 1547 */ 1548 if (exi->exi_export.ex_flags & EX_LOG) { 1549 lb = exi->exi_logbuffer; 1550 1551 /* obtain the unique record id for the caller */ 1552 *nfslog_rec_id = atomic_add_32_nv(&lb->lb_rec_id, (int32_t)1); 1553 1554 /* 1555 * The caller will expect to be able to exi_rele() it, 1556 * so exi->exi_count must be incremented before it can 1557 * be returned, to make it uniform with exi_ret->exi_count 1558 */ 1559 exi_hold(exi); 1560 return (exi); 1561 } 1562 1563 if (exi != exi_public) 1564 return (NULL); 1565 1566 /* 1567 * Here we have an exi that is not marked for logging. 1568 * It is possible that this request is a multicomponent lookup 1569 * that was done from the public file handle (not logged) and 1570 * the resulting file handle being returned to the client exists 1571 * in a file system that is being logged. If this is the case 1572 * we need to log this multicomponent lookup to the appropriate 1573 * log buffer. This will allow for the appropriate path name 1574 * mapping to occur at user level. 1575 */ 1576 if (req->rq_prog == NFS_PROGRAM) { 1577 switch (req->rq_vers) { 1578 case NFS_V3: 1579 if ((req->rq_proc == NFSPROC3_LOOKUP) && 1580 (((LOOKUP3res *)res)->status == NFS3_OK)) { 1581 fh3 = &((LOOKUP3res *)res)->res_u.ok.object; 1582 exi_ret = checkexport(&fh3->fh3_fsid, 1583 FH3TOXFIDP(fh3), NULL); 1584 } 1585 break; 1586 1587 case NFS_VERSION: 1588 if ((req->rq_proc == RFS_LOOKUP) && 1589 (((struct nfsdiropres *) 1590 res)->dr_status == NFS_OK)) { 1591 fh = &((struct nfsdiropres *)res)-> 1592 dr_u.dr_drok_u.drok_fhandle; 1593 exi_ret = checkexport(&fh->fh_fsid, 1594 (fid_t *)&fh->fh_xlen, NULL); 1595 } 1596 break; 1597 default: 1598 break; 1599 } 1600 } 1601 1602 if (exi_ret != NULL && exi_ret->exi_export.ex_flags & EX_LOG) { 1603 lb = exi_ret->exi_logbuffer; 1604 /* obtain the unique record id for the caller */ 1605 *nfslog_rec_id = atomic_add_32_nv(&lb->lb_rec_id, (int32_t)1); 1606 1607 return (exi_ret); 1608 } 1609 return (NULL); 1610 } 1611 1612 #ifdef DEBUG 1613 static long long rfslog_records_ignored = 0; 1614 #endif 1615 1616 /* 1617 * nfslog_write_record - Fill in the record buffer for writing out. 1618 * If logrecp is null, log it, otherwise, malloc the record and return it. 1619 * 1620 * It is the responsibility of the caller to check whether this exportinfo 1621 * has logging enabled. 1622 * Note that nfslog_share_public_record() only needs to check for the 1623 * existence of at least one logbuffer to which the public filehandle record 1624 * needs to be logged. 1625 */ 1626 void 1627 nfslog_write_record(struct exportinfo *exi, struct svc_req *req, caddr_t args, 1628 caddr_t res, cred_t *cr, struct netbuf *pnb, unsigned int record_id, 1629 unsigned int which_buffers) 1630 { 1631 struct nfslog_prog_disp *progtable; /* prog struct */ 1632 struct nfslog_vers_disp *verstable; /* version struct */ 1633 struct nfslog_proc_disp *disp = NULL; /* proc struct */ 1634 int i, vers; 1635 void *log_cookie; /* for logrecord if */ 1636 caddr_t buffer; 1637 XDR xdrs; 1638 unsigned int final_size; 1639 int encode_ok; 1640 int alloc_indx; 1641 1642 ASSERT(exi != NULL); ASSERT(req != NULL); ASSERT(args != NULL); 1643 ASSERT(res != NULL); ASSERT(cr != NULL); 1644 1645 /* 1646 * Find program element 1647 * Search the list since program can not be used as index 1648 */ 1649 for (i = 0; (i < nfslog_dispatch_table_arglen); i++) { 1650 if (req->rq_prog == nfslog_dispatch_table[i].nfslog_dis_prog) 1651 break; 1652 } 1653 if (i >= nfslog_dispatch_table_arglen) { /* program not logged */ 1654 /* not an error */ 1655 return; 1656 } 1657 1658 /* 1659 * Extract the dispatch functions based on program/version 1660 */ 1661 progtable = &nfslog_dispatch_table[i]; 1662 vers = req->rq_vers - progtable->nfslog_dis_versmin; 1663 verstable = &progtable->nfslog_dis_vers_table[vers]; 1664 disp = &verstable->nfslog_dis_proc_table[req->rq_proc]; 1665 1666 if (!(exi->exi_export.ex_flags & EX_LOG_ALLOPS) && 1667 !disp->affects_transactions) { 1668 /* 1669 * Only interested in logging operations affecting 1670 * transaction generation. This is not one of them. 1671 */ 1672 #ifdef DEBUG 1673 rfslog_records_ignored++; 1674 #endif 1675 return; 1676 } 1677 1678 switch (req->rq_prog) { 1679 case NFS_PROGRAM: 1680 switch (req->rq_vers) { 1681 case NFS_V3: 1682 switch (req->rq_proc) { 1683 case NFSPROC3_READDIRPLUS: 1684 alloc_indx = MEDIUM_INDX; 1685 break; 1686 default: 1687 alloc_indx = SMALL_INDX; 1688 break; 1689 } 1690 break; 1691 default: 1692 alloc_indx = SMALL_INDX; 1693 break; 1694 } 1695 break; 1696 case NFSLOG_PROGRAM: 1697 alloc_indx = MEDIUM_INDX; 1698 break; 1699 default: 1700 alloc_indx = SMALL_INDX; 1701 break; 1702 } 1703 1704 do { 1705 encode_ok = FALSE; 1706 1707 /* Pick the size to alloc; end of the road - return */ 1708 if (nfslog_mem_alloc[alloc_indx].size == (-1)) { 1709 cmn_err(CE_WARN, 1710 "NFSLOG: unable to encode record - prog=%d " 1711 "proc = %d", req->rq_prog, req->rq_proc); 1712 return; 1713 } 1714 1715 buffer = nfslog_record_alloc(exi, alloc_indx, &log_cookie, 0); 1716 if (buffer == NULL) { 1717 /* Error processing - no space alloced */ 1718 rfs_log_bad++; 1719 cmn_err(CE_WARN, "NFSLOG: can't get record"); 1720 return; 1721 } 1722 1723 xdrmem_create(&xdrs, buffer, 1724 nfslog_mem_alloc[alloc_indx].size, XDR_ENCODE); 1725 1726 /* 1727 * Encode the header, args and results of the record 1728 */ 1729 if (xdr_nfslog_request_record(&xdrs, exi, req, cr, pnb, 1730 nfslog_mem_alloc[alloc_indx].size, record_id) && 1731 (*disp->xdrargs)(&xdrs, args) && 1732 (*disp->xdrres)(&xdrs, res)) { 1733 encode_ok = TRUE; 1734 1735 rfs_log_good++; 1736 /* 1737 * Get the final size of the encoded 1738 * data and insert that length at the 1739 * beginning. 1740 */ 1741 final_size = xdr_getpos(&xdrs); 1742 xdr_setpos(&xdrs, 0); 1743 (void) xdr_u_int(&xdrs, &final_size); 1744 } else { 1745 /* Oops, the encode failed so we need to free memory */ 1746 nfslog_record_put(log_cookie, 0, FALSE, which_buffers); 1747 alloc_indx++; 1748 } 1749 1750 } while (encode_ok == FALSE); 1751 1752 1753 /* 1754 * Take the final log record and put it in the log file. 1755 * This may be queued to the file internally and written 1756 * later unless the last parameter is TRUE. 1757 * If the record_id is 0 then this is most likely a share/unshare 1758 * request and it should be written synchronously to the log file. 1759 */ 1760 nfslog_record_put(log_cookie, 1761 final_size, (record_id == 0), which_buffers); 1762 } 1763 1764 static char * 1765 get_publicfh_path(int *alloc_length) 1766 { 1767 extern struct exportinfo *exi_public; 1768 char *pubpath; 1769 1770 rw_enter(&exported_lock, RW_READER); 1771 1772 *alloc_length = exi_public->exi_export.ex_pathlen + 1; 1773 pubpath = kmem_alloc(*alloc_length, KM_SLEEP); 1774 1775 (void) strcpy(pubpath, exi_public->exi_export.ex_path); 1776 1777 rw_exit(&exported_lock); 1778 1779 return (pubpath); 1780 } 1781 1782 static void 1783 log_public_record(struct exportinfo *exi, cred_t *cr) 1784 { 1785 struct svc_req req; 1786 struct netbuf nb = {0, 0, NULL}; 1787 int free_length = 0; 1788 diropargs3 args; 1789 LOOKUP3res res; 1790 1791 bzero(&req, sizeof (req)); 1792 req.rq_prog = NFSLOG_PROGRAM; 1793 req.rq_vers = NFSLOG_VERSION; 1794 req.rq_proc = NFSLOG_LOOKUP; 1795 req.rq_cred.oa_flavor = AUTH_NONE; 1796 1797 bzero(&args, sizeof (diropargs3)); 1798 bzero(&res, sizeof (LOOKUP3res)); 1799 1800 args.dir.fh3_length = 0; 1801 if ((args.name = get_publicfh_path(&free_length)) == NULL) 1802 return; 1803 args.dirp = &args.dir; 1804 1805 res.status = NFS3_OK; 1806 res.res_u.ok.object.fh3_length = 0; 1807 1808 /* 1809 * Calling this function with the exi_public 1810 * will have the effect of appending the record 1811 * to each of the open log buffers 1812 */ 1813 nfslog_write_record(exi, &req, 1814 (caddr_t)&args, (caddr_t)&res, cr, &nb, 0, NFSLOG_ALL_BUFFERS); 1815 1816 kmem_free(args.name, free_length); 1817 } 1818 1819 /* 1820 * nfslog_share_record - logs a share request. 1821 * This is not an NFS request, but we pretend here... 1822 */ 1823 void 1824 nfslog_share_record(struct exportinfo *exi, cred_t *cr) 1825 { 1826 struct svc_req req; 1827 int res = 0; 1828 struct netbuf nb = {0, 0, NULL}; 1829 1830 ASSERT(exi != NULL); 1831 1832 if (nfslog_buffer_list == NULL) 1833 return; 1834 1835 if (exi->exi_export.ex_flags & EX_LOG) { 1836 bzero(&req, sizeof (req)); 1837 req.rq_prog = NFSLOG_PROGRAM; 1838 req.rq_vers = NFSLOG_VERSION; 1839 req.rq_proc = NFSLOG_SHARE; 1840 req.rq_cred.oa_flavor = AUTH_NONE; 1841 nfslog_write_record(exi, &req, (caddr_t)exi, (caddr_t)&res, cr, 1842 &nb, 0, NFSLOG_ONE_BUFFER); 1843 } 1844 1845 log_public_record(exi, cr); 1846 } 1847 1848 /* 1849 * nfslog_unshare_record - logs an unshare request. 1850 * This is not an NFS request, but we pretend here... 1851 */ 1852 void 1853 nfslog_unshare_record(struct exportinfo *exi, cred_t *cr) 1854 { 1855 struct svc_req req; 1856 int res = 0; 1857 struct netbuf nb = {0, 0, NULL}; 1858 1859 ASSERT(exi != NULL); 1860 ASSERT(exi->exi_export.ex_flags & EX_LOG); 1861 1862 bzero(&req, sizeof (req)); 1863 req.rq_prog = NFSLOG_PROGRAM; 1864 req.rq_vers = NFSLOG_VERSION; 1865 req.rq_proc = NFSLOG_UNSHARE; 1866 req.rq_cred.oa_flavor = AUTH_NONE; 1867 nfslog_write_record(exi, &req, 1868 (caddr_t)exi, (caddr_t)&res, cr, &nb, 0, NFSLOG_ONE_BUFFER); 1869 } 1870 1871 1872 void 1873 nfslog_getfh(struct exportinfo *exi, fhandle *fh, char *fname, enum uio_seg seg, 1874 cred_t *cr) 1875 { 1876 struct svc_req req; 1877 int res = 0; 1878 struct netbuf nb = {0, 0, NULL}; 1879 int error = 0; 1880 char *namebuf; 1881 size_t len; 1882 nfslog_getfhargs gfh; 1883 1884 ASSERT(exi != NULL); 1885 ASSERT(exi->exi_export.ex_flags & EX_LOG); 1886 1887 bzero(&req, sizeof (req)); 1888 req.rq_prog = NFSLOG_PROGRAM; 1889 req.rq_vers = NFSLOG_VERSION; 1890 req.rq_proc = NFSLOG_GETFH; 1891 req.rq_cred.oa_flavor = AUTH_NONE; 1892 1893 namebuf = kmem_alloc(MAXPATHLEN + 4, KM_SLEEP); 1894 if (seg == UIO_USERSPACE) { 1895 error = copyinstr(fname, namebuf, MAXPATHLEN, &len); 1896 } else { 1897 error = copystr(fname, namebuf, MAXPATHLEN, &len); 1898 } 1899 1900 if (!error) { 1901 gfh.gfh_fh_buf = *fh; 1902 gfh.gfh_path = namebuf; 1903 1904 nfslog_write_record(exi, &req, (caddr_t)&gfh, (caddr_t)&res, 1905 cr, &nb, 0, NFSLOG_ONE_BUFFER); 1906 } 1907 kmem_free(namebuf, MAXPATHLEN + 4); 1908 } 1909