Ccons.c 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398
  1. #include "stdinc.h"
  2. #include "9.h"
  3. enum {
  4. Nl = 256, /* max. command line length */
  5. Nq = 8*1024, /* amount of I/O buffered */
  6. };
  7. typedef struct Q {
  8. VtLock* lock;
  9. VtRendez* full;
  10. VtRendez* empty;
  11. char q[Nq];
  12. int n;
  13. int r;
  14. int w;
  15. } Q;
  16. typedef struct Cons {
  17. VtLock* lock;
  18. int ref;
  19. int closed;
  20. int fd;
  21. int srvfd;
  22. int ctlfd;
  23. Q* iq; /* points to console.iq */
  24. Q* oq; /* points to console.oq */
  25. } Cons;
  26. char *currfsysname;
  27. static struct {
  28. Q* iq; /* input */
  29. Q* oq; /* output */
  30. char l[Nl]; /* command line assembly */
  31. int nl; /* current line length */
  32. int nopens;
  33. char* prompt;
  34. int np;
  35. } console;
  36. static void
  37. consClose(Cons* cons)
  38. {
  39. vtLock(cons->lock);
  40. cons->closed = 1;
  41. cons->ref--;
  42. if(cons->ref > 0){
  43. vtLock(cons->iq->lock);
  44. vtWakeup(cons->iq->full);
  45. vtUnlock(cons->iq->lock);
  46. vtLock(cons->oq->lock);
  47. vtWakeup(cons->oq->empty);
  48. vtUnlock(cons->oq->lock);
  49. vtUnlock(cons->lock);
  50. return;
  51. }
  52. if(cons->ctlfd != -1){
  53. close(cons->ctlfd);
  54. cons->srvfd = -1;
  55. }
  56. if(cons->srvfd != -1){
  57. close(cons->srvfd);
  58. cons->srvfd = -1;
  59. }
  60. if(cons->fd != -1){
  61. close(cons->fd);
  62. cons->fd = -1;
  63. }
  64. vtUnlock(cons->lock);
  65. vtLockFree(cons->lock);
  66. vtMemFree(cons);
  67. console.nopens--;
  68. }
  69. static void
  70. consIProc(void* v)
  71. {
  72. Q *q;
  73. Cons *cons;
  74. int n, w;
  75. char buf[Nq/4];
  76. vtThreadSetName("consI");
  77. cons = v;
  78. q = cons->iq;
  79. for(;;){
  80. /*
  81. * Can't tell the difference between zero-length read
  82. * and eof, so keep calling read until we get an error.
  83. */
  84. if(cons->closed || (n = read(cons->fd, buf, Nq/4)) < 0)
  85. break;
  86. vtLock(q->lock);
  87. while(Nq - q->n < n && !cons->closed)
  88. vtSleep(q->full);
  89. w = Nq - q->w;
  90. if(w < n){
  91. memmove(&q->q[q->w], buf, w);
  92. memmove(&q->q[0], buf + w, n - w);
  93. }
  94. else
  95. memmove(&q->q[q->w], buf, n);
  96. q->w = (q->w + n) % Nq;
  97. q->n += n;
  98. vtWakeup(q->empty);
  99. vtUnlock(q->lock);
  100. }
  101. consClose(cons);
  102. }
  103. static void
  104. consOProc(void* v)
  105. {
  106. Q *q;
  107. Cons *cons;
  108. char buf[Nq];
  109. int lastn, n, r;
  110. vtThreadSetName("consO");
  111. cons = v;
  112. q = cons->oq;
  113. vtLock(q->lock);
  114. lastn = 0;
  115. for(;;){
  116. while(lastn == q->n && !cons->closed)
  117. vtSleep(q->empty);
  118. if((n = q->n - lastn) > Nq)
  119. n = Nq;
  120. if(n > q->w){
  121. r = n - q->w;
  122. memmove(buf, &q->q[Nq - r], r);
  123. memmove(buf+r, &q->q[0], n - r);
  124. }
  125. else
  126. memmove(buf, &q->q[q->w - n], n);
  127. lastn = q->n;
  128. vtUnlock(q->lock);
  129. if(cons->closed || write(cons->fd, buf, n) < 0)
  130. break;
  131. vtLock(q->lock);
  132. vtWakeup(q->empty);
  133. }
  134. consClose(cons);
  135. }
  136. int
  137. consOpen(int fd, int srvfd, int ctlfd)
  138. {
  139. Cons *cons;
  140. cons = vtMemAllocZ(sizeof(Cons));
  141. cons->lock = vtLockAlloc();
  142. cons->fd = fd;
  143. cons->srvfd = srvfd;
  144. cons->ctlfd = ctlfd;
  145. cons->iq = console.iq;
  146. cons->oq = console.oq;
  147. console.nopens++;
  148. vtLock(cons->lock);
  149. cons->ref = 2;
  150. cons->closed = 0;
  151. if(vtThread(consOProc, cons) < 0){
  152. cons->ref--;
  153. vtUnlock(cons->lock);
  154. consClose(cons);
  155. return 0;
  156. }
  157. vtUnlock(cons->lock);
  158. if(ctlfd >= 0)
  159. consIProc(cons);
  160. else if(vtThread(consIProc, cons) < 0){
  161. consClose(cons);
  162. return 0;
  163. }
  164. return 1;
  165. }
  166. static int
  167. qWrite(Q* q, char* p, int n)
  168. {
  169. int w;
  170. vtLock(q->lock);
  171. if(n > Nq - q->w){
  172. w = Nq - q->w;
  173. memmove(&q->q[q->w], p, w);
  174. memmove(&q->q[0], p + w, n - w);
  175. q->w = n - w;
  176. }
  177. else{
  178. memmove(&q->q[q->w], p, n);
  179. q->w += n;
  180. }
  181. q->n += n;
  182. vtWakeup(q->empty);
  183. vtUnlock(q->lock);
  184. return n;
  185. }
  186. static Q*
  187. qAlloc(void)
  188. {
  189. Q *q;
  190. q = vtMemAllocZ(sizeof(Q));
  191. q->lock = vtLockAlloc();
  192. q->full = vtRendezAlloc(q->lock);
  193. q->empty = vtRendezAlloc(q->lock);
  194. q->n = q->r = q->w = 0;
  195. return q;
  196. }
  197. static void
  198. consProc(void*)
  199. {
  200. Q *q;
  201. int argc, i, n, r;
  202. char *argv[20], buf[Nq], *lp, *wbuf;
  203. char procname[64];
  204. snprint(procname, sizeof procname, "cons %s", currfsysname);
  205. vtThreadSetName(procname);
  206. q = console.iq;
  207. qWrite(console.oq, console.prompt, console.np);
  208. vtLock(q->lock);
  209. for(;;){
  210. while((n = q->n) == 0)
  211. vtSleep(q->empty);
  212. r = Nq - q->r;
  213. if(r < n){
  214. memmove(buf, &q->q[q->r], r);
  215. memmove(buf + r, &q->q[0], n - r);
  216. }
  217. else
  218. memmove(buf, &q->q[q->r], n);
  219. q->r = (q->r + n) % Nq;
  220. q->n -= n;
  221. vtWakeup(q->full);
  222. vtUnlock(q->lock);
  223. for(i = 0; i < n; i++){
  224. switch(buf[i]){
  225. case '\004': /* ^D */
  226. if(console.nl == 0){
  227. qWrite(console.oq, "\n", 1);
  228. break;
  229. }
  230. /*FALLTHROUGH*/
  231. default:
  232. if(console.nl < Nl-1){
  233. qWrite(console.oq, &buf[i], 1);
  234. console.l[console.nl++] = buf[i];
  235. }
  236. continue;
  237. case '\b':
  238. if(console.nl != 0){
  239. qWrite(console.oq, &buf[i], 1);
  240. console.nl--;
  241. }
  242. continue;
  243. case '\n':
  244. qWrite(console.oq, &buf[i], 1);
  245. break;
  246. case '\025': /* ^U */
  247. qWrite(console.oq, "^U\n", 3);
  248. console.nl = 0;
  249. break;
  250. case '\027': /* ^W */
  251. console.l[console.nl] = '\0';
  252. wbuf = vtMemAlloc(console.nl+1);
  253. memmove(wbuf, console.l, console.nl+1);
  254. argc = tokenize(wbuf, argv, nelem(argv));
  255. if(argc > 0)
  256. argc--;
  257. console.nl = 0;
  258. lp = console.l;
  259. for(i = 0; i < argc; i++)
  260. lp += sprint(lp, "%q ", argv[i]);
  261. console.nl = lp - console.l;
  262. vtMemFree(wbuf);
  263. qWrite(console.oq, "^W\n", 3);
  264. if(console.nl == 0)
  265. break;
  266. qWrite(console.oq, console.l, console.nl);
  267. continue;
  268. case '\177':
  269. qWrite(console.oq, "\n", 1);
  270. console.nl = 0;
  271. break;
  272. }
  273. console.l[console.nl] = '\0';
  274. if(console.nl != 0)
  275. cliExec(console.l);
  276. console.nl = 0;
  277. qWrite(console.oq, console.prompt, console.np);
  278. }
  279. vtLock(q->lock);
  280. }
  281. }
  282. int
  283. consWrite(char* buf, int len)
  284. {
  285. if(console.oq == nil)
  286. return write(2, buf, len);
  287. if(console.nopens == 0)
  288. write(2, buf, len);
  289. return qWrite(console.oq, buf, len);
  290. }
  291. int
  292. consPrompt(char* prompt)
  293. {
  294. char buf[ERRMAX];
  295. if(prompt == nil)
  296. prompt = "prompt";
  297. vtMemFree(console.prompt);
  298. console.np = snprint(buf, sizeof(buf), "%s: ", prompt);
  299. console.prompt = vtStrDup(buf);
  300. return console.np;
  301. }
  302. int
  303. consTTY(void)
  304. {
  305. int ctl, fd;
  306. char *name, *p;
  307. name = "/dev/cons";
  308. if((fd = open(name, ORDWR)) < 0){
  309. name = "#c/cons";
  310. if((fd = open(name, ORDWR)) < 0){
  311. vtSetError("consTTY: open %s: %r", name);
  312. return 0;
  313. }
  314. }
  315. p = smprint("%sctl", name);
  316. if((ctl = open(p, OWRITE)) < 0){
  317. close(fd);
  318. vtSetError("consTTY: open %s: %r", p);
  319. free(p);
  320. return 0;
  321. }
  322. if(write(ctl, "rawon", 5) < 0){
  323. close(ctl);
  324. close(fd);
  325. vtSetError("consTTY: write %s: %r", p);
  326. free(p);
  327. return 0;
  328. }
  329. free(p);
  330. if(consOpen(fd, fd, ctl) == 0){
  331. close(ctl);
  332. close(fd);
  333. return 0;
  334. }
  335. return 1;
  336. }
  337. int
  338. consInit(void)
  339. {
  340. console.iq = qAlloc();
  341. console.oq = qAlloc();
  342. console.nl = 0;
  343. consPrompt(nil);
  344. if(vtThread(consProc, nil) < 0){
  345. vtFatal("can't start console proc");
  346. return 0;
  347. }
  348. return 1;
  349. }