1 /*- 2 * Copyright (c) 2002, Jeffrey Roberson <jeff@freebsd.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice unmodified, this list of conditions, and the following 10 * disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/kernel.h> 33 #include <sys/kthread.h> 34 #include <sys/lock.h> 35 #include <sys/mount.h> 36 #include <sys/mutex.h> 37 #include <sys/namei.h> 38 #include <sys/proc.h> 39 #include <sys/vnode.h> 40 #include <sys/alq.h> 41 #include <sys/malloc.h> 42 #include <sys/unistd.h> 43 #include <sys/fcntl.h> 44 #include <sys/eventhandler.h> 45 46 #include <security/mac/mac_framework.h> 47 48 /* Async. Logging Queue */ 49 struct alq { 50 int aq_entmax; /* Max entries */ 51 int aq_entlen; /* Entry length */ 52 char *aq_entbuf; /* Buffer for stored entries */ 53 int aq_flags; /* Queue flags */ 54 struct mtx aq_mtx; /* Queue lock */ 55 struct vnode *aq_vp; /* Open vnode handle */ 56 struct ucred *aq_cred; /* Credentials of the opening thread */ 57 struct ale *aq_first; /* First ent */ 58 struct ale *aq_entfree; /* First free ent */ 59 struct ale *aq_entvalid; /* First ent valid for writing */ 60 LIST_ENTRY(alq) aq_act; /* List of active queues */ 61 LIST_ENTRY(alq) aq_link; /* List of all queues */ 62 }; 63 64 #define AQ_WANTED 0x0001 /* Wakeup sleeper when io is done */ 65 #define AQ_ACTIVE 0x0002 /* on the active list */ 66 #define AQ_FLUSHING 0x0004 /* doing IO */ 67 #define AQ_SHUTDOWN 0x0008 /* Queue no longer valid */ 68 69 #define ALQ_LOCK(alq) mtx_lock_spin(&(alq)->aq_mtx) 70 #define ALQ_UNLOCK(alq) mtx_unlock_spin(&(alq)->aq_mtx) 71 72 static MALLOC_DEFINE(M_ALD, "ALD", "ALD"); 73 74 /* 75 * The ald_mtx protects the ald_queues list and the ald_active list. 76 */ 77 static struct mtx ald_mtx; 78 static LIST_HEAD(, alq) ald_queues; 79 static LIST_HEAD(, alq) ald_active; 80 static int ald_shutingdown = 0; 81 struct thread *ald_thread; 82 static struct proc *ald_proc; 83 84 #define ALD_LOCK() mtx_lock(&ald_mtx) 85 #define ALD_UNLOCK() mtx_unlock(&ald_mtx) 86 87 /* Daemon functions */ 88 static int ald_add(struct alq *); 89 static int ald_rem(struct alq *); 90 static void ald_startup(void *); 91 static void ald_daemon(void); 92 static void ald_shutdown(void *, int); 93 static void ald_activate(struct alq *); 94 static void ald_deactivate(struct alq *); 95 96 /* Internal queue functions */ 97 static void alq_shutdown(struct alq *); 98 static int alq_doio(struct alq *); 99 100 101 /* 102 * Add a new queue to the global list. Fail if we're shutting down. 103 */ 104 static int 105 ald_add(struct alq *alq) 106 { 107 int error; 108 109 error = 0; 110 111 ALD_LOCK(); 112 if (ald_shutingdown) { 113 error = EBUSY; 114 goto done; 115 } 116 LIST_INSERT_HEAD(&ald_queues, alq, aq_link); 117 done: 118 ALD_UNLOCK(); 119 return (error); 120 } 121 122 /* 123 * Remove a queue from the global list unless we're shutting down. If so, 124 * the ald will take care of cleaning up it's resources. 125 */ 126 static int 127 ald_rem(struct alq *alq) 128 { 129 int error; 130 131 error = 0; 132 133 ALD_LOCK(); 134 if (ald_shutingdown) { 135 error = EBUSY; 136 goto done; 137 } 138 LIST_REMOVE(alq, aq_link); 139 done: 140 ALD_UNLOCK(); 141 return (error); 142 } 143 144 /* 145 * Put a queue on the active list. This will schedule it for writing. 146 */ 147 static void 148 ald_activate(struct alq *alq) 149 { 150 LIST_INSERT_HEAD(&ald_active, alq, aq_act); 151 wakeup(&ald_active); 152 } 153 154 static void 155 ald_deactivate(struct alq *alq) 156 { 157 LIST_REMOVE(alq, aq_act); 158 alq->aq_flags &= ~AQ_ACTIVE; 159 } 160 161 static void 162 ald_startup(void *unused) 163 { 164 mtx_init(&ald_mtx, "ALDmtx", NULL, MTX_DEF|MTX_QUIET); 165 LIST_INIT(&ald_queues); 166 LIST_INIT(&ald_active); 167 } 168 169 static void 170 ald_daemon(void) 171 { 172 int needwakeup; 173 struct alq *alq; 174 175 ald_thread = FIRST_THREAD_IN_PROC(ald_proc); 176 177 EVENTHANDLER_REGISTER(shutdown_pre_sync, ald_shutdown, NULL, 178 SHUTDOWN_PRI_FIRST); 179 180 ALD_LOCK(); 181 182 for (;;) { 183 while ((alq = LIST_FIRST(&ald_active)) == NULL) 184 msleep(&ald_active, &ald_mtx, PWAIT, "aldslp", 0); 185 186 ALQ_LOCK(alq); 187 ald_deactivate(alq); 188 ALD_UNLOCK(); 189 needwakeup = alq_doio(alq); 190 ALQ_UNLOCK(alq); 191 if (needwakeup) 192 wakeup(alq); 193 ALD_LOCK(); 194 } 195 } 196 197 static void 198 ald_shutdown(void *arg, int howto) 199 { 200 struct alq *alq; 201 202 ALD_LOCK(); 203 ald_shutingdown = 1; 204 205 while ((alq = LIST_FIRST(&ald_queues)) != NULL) { 206 LIST_REMOVE(alq, aq_link); 207 ALD_UNLOCK(); 208 alq_shutdown(alq); 209 ALD_LOCK(); 210 } 211 ALD_UNLOCK(); 212 } 213 214 static void 215 alq_shutdown(struct alq *alq) 216 { 217 ALQ_LOCK(alq); 218 219 /* Stop any new writers. */ 220 alq->aq_flags |= AQ_SHUTDOWN; 221 222 /* Drain IO */ 223 while (alq->aq_flags & (AQ_FLUSHING|AQ_ACTIVE)) { 224 alq->aq_flags |= AQ_WANTED; 225 msleep_spin(alq, &alq->aq_mtx, "aldclose", 0); 226 } 227 ALQ_UNLOCK(alq); 228 229 vn_close(alq->aq_vp, FWRITE, alq->aq_cred, 230 curthread); 231 crfree(alq->aq_cred); 232 } 233 234 /* 235 * Flush all pending data to disk. This operation will block. 236 */ 237 static int 238 alq_doio(struct alq *alq) 239 { 240 struct thread *td; 241 struct mount *mp; 242 struct vnode *vp; 243 struct uio auio; 244 struct iovec aiov[2]; 245 struct ale *ale; 246 struct ale *alstart; 247 int totlen; 248 int iov; 249 int vfslocked; 250 251 vp = alq->aq_vp; 252 td = curthread; 253 totlen = 0; 254 iov = 0; 255 256 alstart = ale = alq->aq_entvalid; 257 alq->aq_entvalid = NULL; 258 259 bzero(&aiov, sizeof(aiov)); 260 bzero(&auio, sizeof(auio)); 261 262 do { 263 if (aiov[iov].iov_base == NULL) 264 aiov[iov].iov_base = ale->ae_data; 265 aiov[iov].iov_len += alq->aq_entlen; 266 totlen += alq->aq_entlen; 267 /* Check to see if we're wrapping the buffer */ 268 if (ale->ae_data + alq->aq_entlen != ale->ae_next->ae_data) 269 iov++; 270 ale->ae_flags &= ~AE_VALID; 271 ale = ale->ae_next; 272 } while (ale->ae_flags & AE_VALID); 273 274 alq->aq_flags |= AQ_FLUSHING; 275 ALQ_UNLOCK(alq); 276 277 if (iov == 2 || aiov[iov].iov_base == NULL) 278 iov--; 279 280 auio.uio_iov = &aiov[0]; 281 auio.uio_offset = 0; 282 auio.uio_segflg = UIO_SYSSPACE; 283 auio.uio_rw = UIO_WRITE; 284 auio.uio_iovcnt = iov + 1; 285 auio.uio_resid = totlen; 286 auio.uio_td = td; 287 288 /* 289 * Do all of the junk required to write now. 290 */ 291 vfslocked = VFS_LOCK_GIANT(vp->v_mount); 292 vn_start_write(vp, &mp, V_WAIT); 293 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 294 /* 295 * XXX: VOP_WRITE error checks are ignored. 296 */ 297 #ifdef MAC 298 if (mac_vnode_check_write(alq->aq_cred, NOCRED, vp) == 0) 299 #endif 300 VOP_WRITE(vp, &auio, IO_UNIT | IO_APPEND, alq->aq_cred); 301 VOP_UNLOCK(vp, 0); 302 vn_finished_write(mp); 303 VFS_UNLOCK_GIANT(vfslocked); 304 305 ALQ_LOCK(alq); 306 alq->aq_flags &= ~AQ_FLUSHING; 307 308 if (alq->aq_entfree == NULL) 309 alq->aq_entfree = alstart; 310 311 if (alq->aq_flags & AQ_WANTED) { 312 alq->aq_flags &= ~AQ_WANTED; 313 return (1); 314 } 315 316 return(0); 317 } 318 319 static struct kproc_desc ald_kp = { 320 "ALQ Daemon", 321 ald_daemon, 322 &ald_proc 323 }; 324 325 SYSINIT(aldthread, SI_SUB_KTHREAD_IDLE, SI_ORDER_ANY, kproc_start, &ald_kp); 326 SYSINIT(ald, SI_SUB_LOCK, SI_ORDER_ANY, ald_startup, NULL); 327 328 329 /* User visible queue functions */ 330 331 /* 332 * Create the queue data structure, allocate the buffer, and open the file. 333 */ 334 int 335 alq_open(struct alq **alqp, const char *file, struct ucred *cred, int cmode, 336 int size, int count) 337 { 338 struct thread *td; 339 struct nameidata nd; 340 struct ale *ale; 341 struct ale *alp; 342 struct alq *alq; 343 char *bufp; 344 int flags; 345 int error; 346 int i, vfslocked; 347 348 *alqp = NULL; 349 td = curthread; 350 351 NDINIT(&nd, LOOKUP, NOFOLLOW | MPSAFE, UIO_SYSSPACE, file, td); 352 flags = FWRITE | O_NOFOLLOW | O_CREAT; 353 354 error = vn_open_cred(&nd, &flags, cmode, 0, cred, NULL); 355 if (error) 356 return (error); 357 358 vfslocked = NDHASGIANT(&nd); 359 NDFREE(&nd, NDF_ONLY_PNBUF); 360 /* We just unlock so we hold a reference */ 361 VOP_UNLOCK(nd.ni_vp, 0); 362 VFS_UNLOCK_GIANT(vfslocked); 363 364 alq = malloc(sizeof(*alq), M_ALD, M_WAITOK|M_ZERO); 365 alq->aq_entbuf = malloc(count * size, M_ALD, M_WAITOK|M_ZERO); 366 alq->aq_first = malloc(sizeof(*ale) * count, M_ALD, M_WAITOK|M_ZERO); 367 alq->aq_vp = nd.ni_vp; 368 alq->aq_cred = crhold(cred); 369 alq->aq_entmax = count; 370 alq->aq_entlen = size; 371 alq->aq_entfree = alq->aq_first; 372 373 mtx_init(&alq->aq_mtx, "ALD Queue", NULL, MTX_SPIN|MTX_QUIET); 374 375 bufp = alq->aq_entbuf; 376 ale = alq->aq_first; 377 alp = NULL; 378 379 /* Match up entries with buffers */ 380 for (i = 0; i < count; i++) { 381 if (alp) 382 alp->ae_next = ale; 383 ale->ae_data = bufp; 384 alp = ale; 385 ale++; 386 bufp += size; 387 } 388 389 alp->ae_next = alq->aq_first; 390 391 if ((error = ald_add(alq)) != 0) 392 return (error); 393 *alqp = alq; 394 395 return (0); 396 } 397 398 /* 399 * Copy a new entry into the queue. If the operation would block either 400 * wait or return an error depending on the value of waitok. 401 */ 402 int 403 alq_write(struct alq *alq, void *data, int waitok) 404 { 405 struct ale *ale; 406 407 if ((ale = alq_get(alq, waitok)) == NULL) 408 return (EWOULDBLOCK); 409 410 bcopy(data, ale->ae_data, alq->aq_entlen); 411 alq_post(alq, ale); 412 413 return (0); 414 } 415 416 struct ale * 417 alq_get(struct alq *alq, int waitok) 418 { 419 struct ale *ale; 420 struct ale *aln; 421 422 ale = NULL; 423 424 ALQ_LOCK(alq); 425 426 /* Loop until we get an entry or we're shutting down */ 427 while ((alq->aq_flags & AQ_SHUTDOWN) == 0 && 428 (ale = alq->aq_entfree) == NULL && 429 (waitok & ALQ_WAITOK)) { 430 alq->aq_flags |= AQ_WANTED; 431 msleep_spin(alq, &alq->aq_mtx, "alqget", 0); 432 } 433 434 if (ale != NULL) { 435 aln = ale->ae_next; 436 if ((aln->ae_flags & AE_VALID) == 0) 437 alq->aq_entfree = aln; 438 else 439 alq->aq_entfree = NULL; 440 } else 441 ALQ_UNLOCK(alq); 442 443 444 return (ale); 445 } 446 447 void 448 alq_post(struct alq *alq, struct ale *ale) 449 { 450 int activate; 451 452 ale->ae_flags |= AE_VALID; 453 454 if (alq->aq_entvalid == NULL) 455 alq->aq_entvalid = ale; 456 457 if ((alq->aq_flags & AQ_ACTIVE) == 0) { 458 alq->aq_flags |= AQ_ACTIVE; 459 activate = 1; 460 } else 461 activate = 0; 462 463 ALQ_UNLOCK(alq); 464 if (activate) { 465 ALD_LOCK(); 466 ald_activate(alq); 467 ALD_UNLOCK(); 468 } 469 } 470 471 void 472 alq_flush(struct alq *alq) 473 { 474 int needwakeup = 0; 475 476 ALD_LOCK(); 477 ALQ_LOCK(alq); 478 if (alq->aq_flags & AQ_ACTIVE) { 479 ald_deactivate(alq); 480 ALD_UNLOCK(); 481 needwakeup = alq_doio(alq); 482 } else 483 ALD_UNLOCK(); 484 ALQ_UNLOCK(alq); 485 486 if (needwakeup) 487 wakeup(alq); 488 } 489 490 /* 491 * Flush remaining data, close the file and free all resources. 492 */ 493 void 494 alq_close(struct alq *alq) 495 { 496 /* 497 * If we're already shuting down someone else will flush and close 498 * the vnode. 499 */ 500 if (ald_rem(alq) != 0) 501 return; 502 503 /* 504 * Drain all pending IO. 505 */ 506 alq_shutdown(alq); 507 508 mtx_destroy(&alq->aq_mtx); 509 free(alq->aq_first, M_ALD); 510 free(alq->aq_entbuf, M_ALD); 511 free(alq, M_ALD); 512 } 513