The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_alq.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 64280ada2e4a573126a4e7d8c4d7ca94


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.