1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/slab.h> /* for kmalloc */ 3 #include <linux/consolemap.h> 4 #include <linux/interrupt.h> 5 #include <linux/sched.h> 6 #include <linux/device.h> /* for dev_warn */ 7 #include <linux/selection.h> 8 #include <linux/workqueue.h> 9 #include <linux/tty.h> 10 #include <linux/tty_flip.h> 11 #include <linux/atomic.h> 12 #include <linux/console.h> 13 14 #include "speakup.h" 15 16 unsigned short spk_xs, spk_ys, spk_xe, spk_ye; /* our region points */ 17 struct vc_data *spk_sel_cons; 18 19 struct speakup_selection_work { 20 struct work_struct work; 21 struct tiocl_selection sel; 22 struct tty_struct *tty; 23 }; 24 25 void speakup_clear_selection(void) 26 { 27 console_lock(); 28 clear_selection(); 29 console_unlock(); 30 } 31 32 static void __speakup_set_selection(struct work_struct *work) 33 { 34 struct speakup_selection_work *ssw = 35 container_of(work, struct speakup_selection_work, work); 36 37 struct tty_struct *tty; 38 struct tiocl_selection sel; 39 40 sel = ssw->sel; 41 42 /* this ensures we copy sel before releasing the lock below */ 43 rmb(); 44 45 /* release the lock by setting tty of the struct to NULL */ 46 tty = xchg(&ssw->tty, NULL); 47 48 if (spk_sel_cons != vc_cons[fg_console].d) { 49 spk_sel_cons = vc_cons[fg_console].d; 50 pr_warn("Selection: mark console not the same as cut\n"); 51 goto unref; 52 } 53 54 set_selection_kernel(&sel, tty); 55 56 unref: 57 tty_kref_put(tty); 58 } 59 60 static struct speakup_selection_work speakup_sel_work = { 61 .work = __WORK_INITIALIZER(speakup_sel_work.work, 62 __speakup_set_selection) 63 }; 64 65 int speakup_set_selection(struct tty_struct *tty) 66 { 67 /* we get kref here first in order to avoid a subtle race when 68 * cancelling selection work. getting kref first establishes the 69 * invariant that if speakup_sel_work.tty is not NULL when 70 * speakup_cancel_selection() is called, it must be the case that a put 71 * kref is pending. 72 */ 73 tty_kref_get(tty); 74 if (cmpxchg(&speakup_sel_work.tty, NULL, tty)) { 75 tty_kref_put(tty); 76 return -EBUSY; 77 } 78 /* now we have the 'lock' by setting tty member of 79 * speakup_selection_work. wmb() ensures that writes to 80 * speakup_sel_work don't happen before cmpxchg() above. 81 */ 82 wmb(); 83 84 speakup_sel_work.sel.xs = spk_xs + 1; 85 speakup_sel_work.sel.ys = spk_ys + 1; 86 speakup_sel_work.sel.xe = spk_xe + 1; 87 speakup_sel_work.sel.ye = spk_ye + 1; 88 speakup_sel_work.sel.sel_mode = TIOCL_SELCHAR; 89 90 schedule_work_on(WORK_CPU_UNBOUND, &speakup_sel_work.work); 91 92 return 0; 93 } 94 95 void speakup_cancel_selection(void) 96 { 97 struct tty_struct *tty; 98 99 cancel_work_sync(&speakup_sel_work.work); 100 /* setting to null so that if work fails to run and we cancel it, 101 * we can run it again without getting EBUSY forever from there on. 102 * we need to use xchg here to avoid race with speakup_set_selection() 103 */ 104 tty = xchg(&speakup_sel_work.tty, NULL); 105 if (tty) 106 tty_kref_put(tty); 107 } 108 109 static void __speakup_paste_selection(struct work_struct *work) 110 { 111 struct speakup_selection_work *ssw = 112 container_of(work, struct speakup_selection_work, work); 113 struct tty_struct *tty = xchg(&ssw->tty, NULL); 114 115 paste_selection(tty); 116 tty_kref_put(tty); 117 } 118 119 static struct speakup_selection_work speakup_paste_work = { 120 .work = __WORK_INITIALIZER(speakup_paste_work.work, 121 __speakup_paste_selection) 122 }; 123 124 int speakup_paste_selection(struct tty_struct *tty) 125 { 126 tty_kref_get(tty); 127 if (cmpxchg(&speakup_paste_work.tty, NULL, tty)) { 128 tty_kref_put(tty); 129 return -EBUSY; 130 } 131 132 schedule_work_on(WORK_CPU_UNBOUND, &speakup_paste_work.work); 133 return 0; 134 } 135 136 void speakup_cancel_paste(void) 137 { 138 struct tty_struct *tty; 139 140 cancel_work_sync(&speakup_paste_work.work); 141 tty = xchg(&speakup_paste_work.tty, NULL); 142 if (tty) 143 tty_kref_put(tty); 144 } 145