tty: Convert tty_buffer flags to bool

The struct tty_buffer has flags which is only used for storing TTYB_NORMAL.
There is also a few quite confusing operations for checking the presense
of TTYB_NORMAL. Simplify things by converting flags to bool.

Despite the name remaining the same, the meaning of "flags" is altered
slightly by this change. Previously it referred to flags of the buffer
(only TTYB_NORMAL being used as a flag). After this change, flags tell
whether the buffer contains/should be allocated with flags array along
with character data array. It is much more suitable name that
TTYB_NORMAL was for this purpose, thus the name remains.

Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
Link: https://lore.kernel.org/r/20221019105504.16800-1-ilpo.jarvinen@linux.intel.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/tty/tty_buffer.c b/drivers/tty/tty_buffer.c
index 3f057805560feccfef407d415b5e6612736e77d3..2df86ed9057426e545e7524f0ab2830d6ba74baa 100644 (file)
--- a/drivers/tty/tty_buffer.c
+++ b/drivers/tty/tty_buffer.c
@@ -107,7 +107,7 @@ static void tty_buffer_reset(struct tty_buffer *p, size_t size)
        p->commit = 0;
        p->lookahead = 0;
        p->read = 0;
-       p->flags = 0;
+       p->flags = true;
 }
 
 /**
@@ -249,7 +249,7 @@ void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld)
  * __tty_buffer_request_room   -       grow tty buffer if needed
  * @port: tty port
  * @size: size desired
- * @flags: buffer flags if new buffer allocated (default = 0)
+ * @flags: buffer has to store flags along character data
  *
  * Make at least @size bytes of linear space available for the tty buffer.
  *
@@ -260,19 +260,19 @@ void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld)
  * Returns: the size we managed to find.
  */
 static int __tty_buffer_request_room(struct tty_port *port, size_t size,
-                                    int flags)
+                                    bool flags)
 {
        struct tty_bufhead *buf = &port->buf;
        struct tty_buffer *b, *n;
        int left, change;
 
        b = buf->tail;
-       if (b->flags & TTYB_NORMAL)
+       if (!b->flags)
                left = 2 * b->size - b->used;
        else
                left = b->size - b->used;
 
-       change = (b->flags & TTYB_NORMAL) && (~flags & TTYB_NORMAL);
+       change = !b->flags && flags;
        if (change || left < size) {
                /* This is the slow path - looking for new buffers to use */
                n = tty_buffer_alloc(port, size);
@@ -300,7 +300,7 @@ static int __tty_buffer_request_room(struct tty_port *port, size_t size,
 
 int tty_buffer_request_room(struct tty_port *port, size_t size)
 {
-       return __tty_buffer_request_room(port, size, 0);
+       return __tty_buffer_request_room(port, size, true);
 }
 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
 
@@ -320,17 +320,17 @@ int tty_insert_flip_string_fixed_flag(struct tty_port *port,
                const unsigned char *chars, char flag, size_t size)
 {
        int copied = 0;
+       bool flags = flag != TTY_NORMAL;
 
        do {
                int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
-               int flags = (flag == TTY_NORMAL) ? TTYB_NORMAL : 0;
                int space = __tty_buffer_request_room(port, goal, flags);
                struct tty_buffer *tb = port->buf.tail;
 
                if (unlikely(space == 0))
                        break;
                memcpy(char_buf_ptr(tb, tb->used), chars, space);
-               if (~tb->flags & TTYB_NORMAL)
+               if (tb->flags)
                        memset(flag_buf_ptr(tb, tb->used), flag, space);
                tb->used += space;
                copied += space;
@@ -393,13 +393,13 @@ EXPORT_SYMBOL(tty_insert_flip_string_flags);
 int __tty_insert_flip_char(struct tty_port *port, unsigned char ch, char flag)
 {
        struct tty_buffer *tb;
-       int flags = (flag == TTY_NORMAL) ? TTYB_NORMAL : 0;
+       bool flags = flag != TTY_NORMAL;
 
        if (!__tty_buffer_request_room(port, 1, flags))
                return 0;
 
        tb = port->buf.tail;
-       if (~tb->flags & TTYB_NORMAL)
+       if (tb->flags)
                *flag_buf_ptr(tb, tb->used) = flag;
        *char_buf_ptr(tb, tb->used++) = ch;
 
@@ -424,13 +424,13 @@ EXPORT_SYMBOL(__tty_insert_flip_char);
 int tty_prepare_flip_string(struct tty_port *port, unsigned char **chars,
                size_t size)
 {
-       int space = __tty_buffer_request_room(port, size, TTYB_NORMAL);
+       int space = __tty_buffer_request_room(port, size, false);
 
        if (likely(space)) {
                struct tty_buffer *tb = port->buf.tail;
 
                *chars = char_buf_ptr(tb, tb->used);
-               if (~tb->flags & TTYB_NORMAL)
+               if (tb->flags)
                        memset(flag_buf_ptr(tb, tb->used), TTY_NORMAL, space);
                tb->used += space;
        }
@@ -492,7 +492,7 @@ static void lookahead_bufs(struct tty_port *port, struct tty_buffer *head)
                        unsigned char *p, *f = NULL;
 
                        p = char_buf_ptr(head, head->lookahead);
-                       if (~head->flags & TTYB_NORMAL)
+                       if (head->flags)
                                f = flag_buf_ptr(head, head->lookahead);
 
                        port->client_ops->lookahead_buf(port, p, f, count);
@@ -509,7 +509,7 @@ receive_buf(struct tty_port *port, struct tty_buffer *head, int count)
        const char *f = NULL;
        int n;
 
-       if (~head->flags & TTYB_NORMAL)
+       if (head->flags)
                f = flag_buf_ptr(head, head->read);
 
        n = port->client_ops->receive_buf(port, p, f, count);

diff --git a/include/linux/tty_buffer.h b/include/linux/tty_buffer.h
index 1796648c290738a234646def8203bd175ef4526e..6ceb2789e6c816bc98601f9b106e2e14df005fb2 100644 (file)
--- a/include/linux/tty_buffer.h
+++ b/include/linux/tty_buffer.h
@@ -17,14 +17,11 @@ struct tty_buffer {
        int commit;
        int lookahead;          /* Lazy update on recv, can become less than "read" */
        int read;
-       int flags;
+       bool flags;
        /* Data points here */
        unsigned long data[];
 };
 
-/* Values for .flags field of tty_buffer */
-#define TTYB_NORMAL    1       /* buffer has no flags buffer */
-
 static inline unsigned char *char_buf_ptr(struct tty_buffer *b, int ofs)
 {
        return ((unsigned char *)b->data) + ofs;

diff --git a/include/linux/tty_flip.h b/include/linux/tty_flip.h
index 483d41cbcbb70c7a161553008c5009784f5c9d2c..bfaaeee61a050443bcd3ceb8aa8895bc3bb8d394 100644 (file)
--- a/include/linux/tty_flip.h
+++ b/include/linux/tty_flip.h
@@ -25,9 +25,9 @@ static inline int tty_insert_flip_char(struct tty_port *port,
        struct tty_buffer *tb = port->buf.tail;
        int change;
 
-       change = (tb->flags & TTYB_NORMAL) && (flag != TTY_NORMAL);
+       change = !tb->flags && (flag != TTY_NORMAL);
        if (!change && tb->used < tb->size) {
-               if (~tb->flags & TTYB_NORMAL)
+               if (tb->flags)
                        *flag_buf_ptr(tb, tb->used) = flag;
                *char_buf_ptr(tb, tb->used++) = ch;
                return 1;