sys/kern/tty_subr.c

   1 /*
   2  * Copyright (c) 1994, David Greenman
   3  * All rights reserved.
   4  * Copyright (c) 2003-2011 The DragonFly Project.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to The DragonFly Project
   7   * by Matthew Dillon <dillon@backplane.com>
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice unmodified, this list of conditions, and the following
  14  *    disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * clist support routines
  34  *
  35  * The clist now contains two linear buffers c_quote and c_info, sized
  36  * to c_cbmax.  The caller must hold a lock or token specific to the clist
  37  * being manipulated.
  38  */
  39 #include <sys/param.h>
  40 #include <sys/kernel.h>
  41 #include <sys/systm.h>
  42 #include <sys/malloc.h>
  43 #include <sys/tty.h>
  44 #include <sys/thread2.h>
  45
  46 /*
  47  * Allocate or reallocate clist buffers.
  48  */
  49 void
  50 clist_alloc_cblocks(struct clist *cl, int ccmax)
  51 {
  52         short *data;
  53         int count;
  54         int n;
  55
  56         if (ccmax == cl->c_ccmax)
  57                 return;
  58         if (ccmax == 0) {
  59                 clist_free_cblocks(cl);
  60                 return;
  61         }
  62         data = kmalloc(ccmax * sizeof(*data), M_TTYS, M_INTWAIT|M_ZERO);
  63         /* NOTE: cl fields may now be different due to blocking */
  64
  65         count = cl->c_cc;
  66         if (cl->c_cc) {
  67                 if (count > ccmax)
  68                         count = ccmax;
  69                 n = cl->c_ccmax - cl->c_cchead;
  70                 if (n > count)
  71                         n = count;
  72                 bcopy(cl->c_data + cl->c_cchead, data, n * sizeof(*data));
  73                 if (n < count) {
  74                         bcopy(cl->c_data, data + n,
  75                               (count - n) * sizeof(*data));
  76                 }
  77         }
  78         cl->c_cc = count;
  79         cl->c_ccmax = ccmax;
  80         cl->c_cchead = 0;
  81         cl->c_data = data;
  82 }
  83
  84 /*
  85  * Free the clist's buffer.
  86  */
  87 void
  88 clist_free_cblocks(struct clist *cl)
  89 {
  90         short *data;
  91
  92         data = cl->c_data;
  93
  94         cl->c_cc = 0;
  95         cl->c_ccmax = 0;
  96         cl->c_cchead = 0;
  97         cl->c_unused01 = 0;
  98         cl->c_data = NULL;
  99         if (data)
 100                 kfree(data, M_TTYS);
 101 }
 102
 103 /*
 104  * Get a character from the head of a clist.
 105  */
 106 int
 107 clist_getc(struct clist *cl)
 108 {
 109         short c;
 110         int i;
 111
 112         if (cl->c_cc == 0)
 113                 return -1;
 114         i = cl->c_cchead;
 115         c = cl->c_data[i];
 116         if (++i == cl->c_ccmax)
 117                 i = 0;
 118         cl->c_cchead = i;
 119         --cl->c_cc;
 120         return ((int)c);
 121 }
 122
 123 /*
 124  * Copy data from the clist to the destination linear buffer.
 125  * Return the number of characters actually copied.
 126  */
 127 int
 128 clist_qtob(struct clist *cl, char *dest, int n)
 129 {
 130         int count;
 131         int i;
 132         short c;
 133
 134         if (n > cl->c_cc)
 135                 n = cl->c_cc;
 136         count = n;
 137         i = cl->c_cchead;
 138
 139         while (n) {
 140                 c = cl->c_data[i];
 141                 if (++i == cl->c_ccmax)
 142                         i = 0;
 143                 *dest++ = (char)c;
 144                 --n;
 145         }
 146         cl->c_cchead = i;
 147         cl->c_cc -= count;
 148
 149         return count;
 150 }
 151
 152 /*
 153  * Flush characters from the head of the clist, deleting them.
 154  */
 155 void
 156 ndflush(struct clist *cl, int n)
 157 {
 158         int i;
 159
 160         if (n > cl->c_cc)
 161                 n = cl->c_cc;
 162         i = cl->c_cchead + n;
 163         if (i >= cl->c_ccmax)
 164                 i -= cl->c_ccmax;
 165         cl->c_cchead = i;
 166         cl->c_cc -= n;
 167 }
 168
 169 /*
 170  * Append a character to the clist, return 0 on success, -1 if
 171  * there is no room.  The character can be quoted by setting TTY_QUOTE.
 172  */
 173 int
 174 clist_putc(int c, struct clist *cl)
 175 {
 176         int i;
 177
 178         if (cl->c_cc == cl->c_ccmax)
 179                 return -1;
 180         i = cl->c_cchead + cl->c_cc;
 181         if (i >= cl->c_ccmax)
 182                 i -= cl->c_ccmax;
 183         cl->c_data[i] = (short)c & (TTY_QUOTE | TTY_CHARMASK);
 184         ++cl->c_cc;
 185
 186         return 0;
 187 }
 188
 189 /*
 190  * Copy data from linear buffer to clist chain.  Return the
 191  * number of characters not copied.  The data will be flagged
 192  * as not being quoted.
 193  */
 194 int
 195 clist_btoq(char *src, int n, struct clist *cl)
 196 {
 197         int i;
 198         int count;
 199         int remain;
 200
 201         count = cl->c_ccmax - cl->c_cc;         /* space available */
 202         if (count > n)
 203                 count = n;                      /* count = bytes to copy */
 204         remain = n - count;                     /* remain = bytes not copied */
 205
 206         i = cl->c_cchead + cl->c_cc;            /* clist write index */
 207         if (i >= cl->c_ccmax)
 208                 i -= cl->c_ccmax;
 209
 210         while (count) {
 211                 cl->c_data[i] = (short)(uint8_t)*src;
 212                 if (++i == cl->c_ccmax)
 213                         i = 0;
 214                 ++src;
 215                 --count;
 216         }
 217         cl->c_cc += n - remain;                 /* bytes actually copied */
 218
 219         return remain;                          /* return bytes not copied */
 220 }
 221
 222 /*
 223  * Get the next character in the clist relative to cp.  If cp is NULL
 224  * returns the first character in the clist.  The character is stored in
 225  * *dst.  No clist pointers are advanced or adjusted.
 226  *
 227  * The returned pointer can be used as an iterator but should not be
 228  * directly dereferenced.
 229  */
 230 void *
 231 clist_nextc(struct clist *cl, void *cp, int *dst)
 232 {
 233         int i;
 234
 235         if (cp == NULL) {
 236                 if (cl->c_cc == 0) {
 237                         *dst = -1;
 238                         return NULL;
 239                 }
 240                 cp = &cl->c_data[cl->c_cchead];
 241                 *dst = (uint16_t)*(short *)cp;  /* can be quoted */
 242                 return cp;
 243         }
 244
 245         /*
 246          * Use i to calculate the next logical index to determine if
 247          * there are any characters remaining.
 248          */
 249         i = (short *)cp - cl->c_data;
 250         if (i < cl->c_cchead)
 251                 i += cl->c_ccmax - cl->c_cchead;
 252         else
 253                 i -= cl->c_cchead;
 254         if (i + 1 == cl->c_cc) {                /* no more chars */
 255                 *dst = 0;
 256                 return NULL;
 257         }
 258
 259         /*
 260          * We can just use cp to iterate the next actual buffer
 261          * position.
 262          */
 263         cp = (short *)cp + 1;                   /* next char (use pointer) */
 264         if (cp == &cl->c_data[cl->c_ccmax])
 265                 cp = &cl->c_data[0];
 266         *dst = (uint16_t)*(short *)cp;
 267
 268         return cp;
 269 }
 270
 271 /*
 272  * "Unput" a character from a clist, returning it.
 273  */
 274 int
 275 clist_unputc(struct clist *cl)
 276 {
 277         int c;
 278         int i;
 279
 280         if (cl->c_cc == 0)
 281                 return -1;
 282         --cl->c_cc;
 283         i = cl->c_cchead + cl->c_cc;
 284         if (i >= cl->c_ccmax)
 285                 i -= cl->c_ccmax;
 286         c = (int)(uint16_t)cl->c_data[i];
 287
 288         return c;
 289 }
 290
 291 /*
 292  * Move characters in source clist to destination clist,
 293  * preserving quote bits.  Non-critical path.
 294  */
 295 void
 296 clist_catq(struct clist *cls, struct clist *cld)
 297 {
 298         int c;
 299
 300         while ((c = clist_getc(cls)) != -1)
 301                 clist_putc(c, cld);
 302 }