summaryrefslogtreecommitdiff
path: root/libcons/cons.h
blob: e7484db55320ad7d5afe5b5a1973bbd6f6459781 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
/* cons.h - Definitions for cons helper and callback functions.
   Copyright (C) 2002 Free Software Foundation, Inc.
   Written by Marcus Brinkmann.

   This file is part of the GNU Hurd.

   The GNU Hurd is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2, or (at
   your option) any later version.

   The GNU Hurd is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA. */

#ifndef _HURD_CONS_H
#define _HURD_CONS_H

#include <dirent.h>

#include <hurd/ports.h>
#include <mach.h>

#include <hurd/console.h>

typedef struct cons *cons_t;
typedef struct vcons_list *vcons_list_t;
typedef struct vcons *vcons_t;
typedef struct cons_notify *cons_notify_t;

struct vcons_list
{
  cons_t cons;
  vcons_list_t next;
  vcons_list_t prev;

  /* The ID of the virtual console entry in the list.  */
  int id;

  /* The opened vcons port on which we receive notifications.  */
  vcons_t vcons;
};

struct cons_notify
{
  struct port_info pi;

  /* This is set for the dir notification port.  */
  cons_t cons;
};

struct vcons
{
  /* This must come first for the port info structure.  */
  struct cons_notify notify;

  /* These elements are static from creation time.  */
  cons_t cons;
  vcons_list_t vcons_entry;
  int id;

  /* The lock that protects all other members.  */
  struct mutex lock;

  /* The FD of the input node.  */
  int input;

  /* The shared memory of the display.  */
  struct cons_display *display;
  size_t display_size;

  struct
  {
    struct
    {
      uint32_t col;
      uint32_t row;
      uint32_t status;
    } cursor;
    struct
    {
      uint32_t width;
      uint32_t height;
      uint32_t lines;
      uint32_t cur_line;
      uint32_t scr_lines;
      conchar_t *matrix;
    } screen;
    struct
    {
      uint32_t audible;
      uint32_t visible;
    } bell;
    struct
    {
      uint32_t written;
      uint32_t length;
      cons_change_t *buffer;
    } changes;
  } state;
};

struct cons
{
  /* Protects the cons structure and the linked list in
     VCONS_LIST.  */
  struct mutex lock;
  vcons_list_t vcons_list;
  vcons_list_t vcons_last;

  struct port_class *port_class;
  struct port_bucket *port_bucket;
  DIR *dir;
  io_t dirport;
  int slack;
};


/* The user must define this variable.  Set this to the name of the
   console client.  */
extern const char *cons_client_name;

/* The user must define this variable.  Set this to be the client
   version number.  */
extern const char *cons_client_version;

/* The user may define this variable.  Set this to be any additional
   version specification that should be printed for --version. */
extern char *cons_extra_version;

/* The user must define this function.  Write LENGTH characters
   starting from STR on the virtual console VCONS, which is locked,
   starting from position COL and ROW.  */
void cons_vcons_write (vcons_t vcons, conchar_t *str, size_t length,
		       uint32_t col, uint32_t row);

/* The user must define this function.  Set the cursor on virtual
   console VCONS, which is locked, to position COL and ROW.  */
void cons_vcons_set_cursor_pos (vcons_t vcons, uint32_t col, uint32_t row);

/* The user must define this function.  Set the cursor status of
   virtual console VCONS, which is locked, to STATUS.  */
void cons_vcons_set_cursor_status (vcons_t vcons, uint32_t status);

/* The user must define this function.  Scroll the content of virtual
   console VCONS, which is locked, up by DELTA if DELTA is positive or
   down by -DELTA if DELTA is negative.  DELTA will never be zero, and
   the absolute value if DELTA will be smaller than or equal to the
   height of the screen matrix.

   This call will be immediately followed by corresponding
   cons_vcons_write calls to fill the resulting gap on the screen, and
   VCONS will be looked throughout the whole time.  The purpose of the
   function is two-fold: It is called with an absolute value of DELTA
   smaller than the screen height to perform scrolling.  It is called
   with an absolute value of DELTA equal to the screen height to
   prepare a full refresh of the screen.  In the latter case the user
   should not really perform any scrolling.  Instead it might
   deallocate limited resources (like display glyph slots and palette
   colors) if that helps to perform the subsequent write.  It goes
   without saying that the same deallocation, if any, should be
   performed on the area that will be filled with the scrolled in
   content.

   XXX Possibly need a function to invalidate scrollback buffer, or in
   general to signal a switch of the console so state can be reset.
   Only do this if we make guarantees about validity of scrollback
   buffer, of course.

   The driver is allowed to delay the effect of this operation until
   the UPDATE function is called.  */
void cons_vcons_scroll (vcons_t vcons, int delta);

/* The user may define this function.  Make the changes from
   cons_vcons_write, cons_vcons_set_cursor_pos,
   cons_vcons_set_cursor_status and cons_vcons_scroll active.  VCONS
   is locked and will have been continuously locked from the first
   change since the last update on.  This is the latest possible point
   the user must make the changes visible from.  The user can always
   make the changes visible at a more convenient, earlier time.  */
void cons_vcons_update (vcons_t vcons);

/* The user must define this function.  Make the virtual console
   VCONS, which is locked, beep audible.  */
void cons_vcons_beep (vcons_t vcons);

/* The user must define this function.  Make the virtual console
   VCONS, which is locked, flash visibly.  */
void cons_vcons_flash (vcons_t vcons);

/* The user must define this function.  It is called whenever a
   virtual console is selected to be the active one.  It is the user's
   responsibility to close the console at some later time.  */
error_t cons_vcons_activate (vcons_t vcons);

/* The user may define this function.  It is called after a
   virtual console entry was added.  CONS is locked.  */
void cons_vcons_add (cons_t cons, vcons_list_t vcons_entry);

/* The user may define this function.  It is called just before a
   virtual console entry is removed.  CONS is locked.  */
void cons_vcons_remove (cons_t cons, vcons_list_t vcons_entry);

/* Open the virtual console ID or the ACTIVE_ID plus DELTA one in CONS
   and return it in R_VCONS.  */
error_t cons_switch (cons_t cons, int active_id, int id, int delta,
		     vcons_t *r_vcons);


extern const struct argp cons_startup_argp;

extern struct port_bucket *cons_port_bucket;
extern struct port_class *cons_port_class;

error_t cons_init (void);
void cons_server_loop (void);
int cons_demuxer (mach_msg_header_t *inp, mach_msg_header_t *outp);

/* Lookup the virtual console with number ID in the console CONS,
   acquire a reference for it, and return its list entry in R_VCONS.
   If CREATE is true, the virtual console will be created if it
   doesn't exist yet.  If CREATE is true, and ID 0, the first free
   virtual console id is used.  CONS must be locked.  */
error_t cons_lookup (cons_t cons, int id, int create, vcons_list_t *r_vcons);

/* Open the virtual console for VCONS_ENTRY.  CONS is locked.  */
error_t cons_vcons_open (cons_t cons, vcons_list_t vcons_entry,
			 vcons_t *r_vcons);

/* Close the virtual console VCONS.  VCONS->cons is locked.  */
void cons_vcons_close (vcons_t vcons);

/* Destroy the virtual console VCONS.  */
void cons_vcons_destroy (void *port);

/* Redraw the virtual console VCONS, which is locked.  */
void cons_vcons_refresh (vcons_t vcons);

#endif	/* hurd/cons.h */