tty: vt/keyboard: use guard()s · tjh.dev/kernel@dee7e10

+74 -136

1 changed file

expand all

drivers

tty

keyboard.c

+74 -136

drivers/tty/vt/keyboard.c

··· 424 424 /* We still have to export this method to vt.c */ 425 425 void vt_set_leds_compute_shiftstate(void) 426 426 { 427 - unsigned long flags; 428 - 429 427 /* 430 428 * When VT is switched, the keyboard led needs to be set once. 431 429 * Ensure that after the switch is completed, the state of the ··· 432 434 vt_switch = true; 433 435 set_leds(); 434 436 435 - spin_lock_irqsave(&kbd_event_lock, flags); 437 + guard(spinlock_irqsave)(&kbd_event_lock); 436 438 do_compute_shiftstate(); 437 - spin_unlock_irqrestore(&kbd_event_lock, flags); 438 439 } 439 440 440 441 /* ··· 622 625 623 626 static void fn_spawn_con(struct vc_data *vc) 624 627 { 625 - spin_lock(&vt_spawn_con.lock); 628 + guard(spinlock)(&vt_spawn_con.lock); 626 629 if (vt_spawn_con.pid) 627 630 if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) { 628 631 put_pid(vt_spawn_con.pid); 629 632 vt_spawn_con.pid = NULL; 630 633 } 631 - spin_unlock(&vt_spawn_con.lock); 632 634 } 633 635 634 636 static void fn_SAK(struct vc_data *vc) ··· 758 762 return; 759 763 760 764 if ((unsigned)value < ARRAY_SIZE(func_table)) { 761 - unsigned long flags; 762 - 763 - spin_lock_irqsave(&func_buf_lock, flags); 765 + guard(spinlock_irqsave)(&func_buf_lock); 764 766 if (func_table[value]) 765 767 puts_queue(vc, func_table[value]); 766 - spin_unlock_irqrestore(&func_buf_lock, flags); 767 - 768 768 } else 769 769 pr_err("k_fn called with value=%d\n", value); 770 770 } ··· 1132 1140 1133 1141 void setledstate(struct kbd_struct *kb, unsigned int led) 1134 1142 { 1135 - unsigned long flags; 1136 - spin_lock_irqsave(&led_lock, flags); 1143 + guard(spinlock_irqsave)(&led_lock); 1137 1144 if (!(led & ~7)) { 1138 1145 ledioctl = led; 1139 1146 kb->ledmode = LED_SHOW_IOCTL; ··· 1140 1149 kb->ledmode = LED_SHOW_FLAGS; 1141 1150 1142 1151 set_leds(); 1143 - spin_unlock_irqrestore(&led_lock, flags); 1144 1152 } 1145 1153 1146 1154 static inline unsigned char getleds(void) ··· 1162 1172 int vt_get_leds(unsigned int console, int flag) 1163 1173 { 1164 1174 struct kbd_struct *kb = &kbd_table[console]; 1165 - int ret; 1166 - unsigned long flags; 1167 1175 1168 - spin_lock_irqsave(&led_lock, flags); 1169 - ret = vc_kbd_led(kb, flag); 1170 - spin_unlock_irqrestore(&led_lock, flags); 1171 - 1172 - return ret; 1176 + guard(spinlock_irqsave)(&led_lock); 1177 + return vc_kbd_led(kb, flag); 1173 1178 } 1174 1179 EXPORT_SYMBOL_GPL(vt_get_leds); 1175 1180 ··· 1198 1213 void vt_kbd_con_start(unsigned int console) 1199 1214 { 1200 1215 struct kbd_struct *kb = &kbd_table[console]; 1201 - unsigned long flags; 1202 - spin_lock_irqsave(&led_lock, flags); 1216 + 1217 + guard(spinlock_irqsave)(&led_lock); 1203 1218 clr_vc_kbd_led(kb, VC_SCROLLOCK); 1204 1219 set_leds(); 1205 - spin_unlock_irqrestore(&led_lock, flags); 1206 1220 } 1207 1221 1208 1222 /** ··· 1214 1230 void vt_kbd_con_stop(unsigned int console) 1215 1231 { 1216 1232 struct kbd_struct *kb = &kbd_table[console]; 1217 - unsigned long flags; 1218 - spin_lock_irqsave(&led_lock, flags); 1233 + 1234 + guard(spinlock_irqsave)(&led_lock); 1219 1235 set_vc_kbd_led(kb, VC_SCROLLOCK); 1220 1236 set_leds(); 1221 - spin_unlock_irqrestore(&led_lock, flags); 1222 1237 } 1223 1238 1224 1239 /* ··· 1229 1246 static void kbd_bh(struct tasklet_struct *unused) 1230 1247 { 1231 1248 unsigned int leds; 1232 - unsigned long flags; 1233 1249 1234 - spin_lock_irqsave(&led_lock, flags); 1235 - leds = getleds(); 1236 - leds |= (unsigned int)kbd->lockstate << 8; 1237 - spin_unlock_irqrestore(&led_lock, flags); 1250 + scoped_guard(spinlock_irqsave, &led_lock) { 1251 + leds = getleds(); 1252 + leds |= (unsigned int)kbd->lockstate << 8; 1253 + } 1238 1254 1239 1255 if (vt_switch) { 1240 1256 ledstate = ~leds; ··· 1507 1525 unsigned int event_code, int value) 1508 1526 { 1509 1527 /* We are called with interrupts disabled, just take the lock */ 1510 - spin_lock(&kbd_event_lock); 1511 - 1512 - if (event_type == EV_MSC && event_code == MSC_RAW && 1513 - kbd_is_hw_raw(handle->dev)) 1514 - kbd_rawcode(value); 1515 - if (event_type == EV_KEY && event_code <= KEY_MAX) 1516 - kbd_keycode(event_code, value, kbd_is_hw_raw(handle->dev)); 1517 - 1518 - spin_unlock(&kbd_event_lock); 1528 + scoped_guard(spinlock, &kbd_event_lock) { 1529 + if (event_type == EV_MSC && event_code == MSC_RAW && 1530 + kbd_is_hw_raw(handle->dev)) 1531 + kbd_rawcode(value); 1532 + if (event_type == EV_KEY && event_code <= KEY_MAX) 1533 + kbd_keycode(event_code, value, kbd_is_hw_raw(handle->dev)); 1534 + } 1519 1535 1520 1536 tasklet_schedule(&keyboard_tasklet); 1521 1537 do_poke_blanked_console = 1; ··· 1660 1680 */ 1661 1681 int vt_do_diacrit(unsigned int cmd, void __user *udp, int perm) 1662 1682 { 1663 - unsigned long flags; 1664 1683 int asize; 1665 1684 1666 1685 switch (cmd) { ··· 1675 1696 1676 1697 /* Lock the diacriticals table, make a copy and then 1677 1698 copy it after we unlock */ 1678 - spin_lock_irqsave(&kbd_event_lock, flags); 1679 - 1680 - asize = accent_table_size; 1681 - for (i = 0; i < asize; i++) { 1682 - dia[i].diacr = conv_uni_to_8bit( 1683 - accent_table[i].diacr); 1684 - dia[i].base = conv_uni_to_8bit( 1685 - accent_table[i].base); 1686 - dia[i].result = conv_uni_to_8bit( 1687 - accent_table[i].result); 1699 + scoped_guard(spinlock_irqsave, &kbd_event_lock) { 1700 + asize = accent_table_size; 1701 + for (i = 0; i < asize; i++) { 1702 + dia[i].diacr = conv_uni_to_8bit(accent_table[i].diacr); 1703 + dia[i].base = conv_uni_to_8bit(accent_table[i].base); 1704 + dia[i].result = conv_uni_to_8bit(accent_table[i].result); 1705 + } 1688 1706 } 1689 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1690 1707 1691 1708 if (put_user(asize, &a->kb_cnt)) 1692 1709 return -EFAULT; ··· 1701 1726 1702 1727 /* Lock the diacriticals table, make a copy and then 1703 1728 copy it after we unlock */ 1704 - spin_lock_irqsave(&kbd_event_lock, flags); 1705 - 1706 - asize = accent_table_size; 1707 - memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc)); 1708 - 1709 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1729 + scoped_guard(spinlock_irqsave, &kbd_event_lock) { 1730 + asize = accent_table_size; 1731 + memcpy(buf, accent_table, asize * sizeof(struct kbdiacruc)); 1732 + } 1710 1733 1711 1734 if (put_user(asize, &a->kb_cnt)) 1712 1735 return -EFAULT; ··· 1735 1762 return PTR_ERR(dia); 1736 1763 } 1737 1764 1738 - spin_lock_irqsave(&kbd_event_lock, flags); 1765 + guard(spinlock_irqsave)(&kbd_event_lock); 1739 1766 accent_table_size = ct; 1740 1767 for (i = 0; i < ct; i++) { 1741 1768 accent_table[i].diacr = ··· 1745 1772 accent_table[i].result = 1746 1773 conv_8bit_to_uni(dia[i].result); 1747 1774 } 1748 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1749 1775 1750 1776 return 0; 1751 1777 } ··· 1769 1797 ct, sizeof(struct kbdiacruc)); 1770 1798 if (IS_ERR(buf)) 1771 1799 return PTR_ERR(buf); 1772 - } 1773 - spin_lock_irqsave(&kbd_event_lock, flags); 1800 + } 1801 + guard(spinlock_irqsave)(&kbd_event_lock); 1774 1802 if (ct) 1775 1803 memcpy(accent_table, buf, 1776 1804 ct * sizeof(struct kbdiacruc)); 1777 1805 accent_table_size = ct; 1778 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1779 1806 return 0; 1780 1807 } 1781 1808 } ··· 1792 1821 int vt_do_kdskbmode(unsigned int console, unsigned int arg) 1793 1822 { 1794 1823 struct kbd_struct *kb = &kbd_table[console]; 1795 - int ret = 0; 1796 - unsigned long flags; 1797 1824 1798 - spin_lock_irqsave(&kbd_event_lock, flags); 1825 + guard(spinlock_irqsave)(&kbd_event_lock); 1799 1826 switch(arg) { 1800 1827 case K_RAW: 1801 1828 kb->kbdmode = VC_RAW; 1802 - break; 1829 + return 0; 1803 1830 case K_MEDIUMRAW: 1804 1831 kb->kbdmode = VC_MEDIUMRAW; 1805 - break; 1832 + return 0; 1806 1833 case K_XLATE: 1807 1834 kb->kbdmode = VC_XLATE; 1808 1835 do_compute_shiftstate(); 1809 - break; 1836 + return 0; 1810 1837 case K_UNICODE: 1811 1838 kb->kbdmode = VC_UNICODE; 1812 1839 do_compute_shiftstate(); 1813 - break; 1840 + return 0; 1814 1841 case K_OFF: 1815 1842 kb->kbdmode = VC_OFF; 1816 - break; 1843 + return 0; 1817 1844 default: 1818 - ret = -EINVAL; 1845 + return -EINVAL; 1819 1846 } 1820 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1821 - return ret; 1822 1847 } 1823 1848 1824 1849 /** ··· 1828 1861 int vt_do_kdskbmeta(unsigned int console, unsigned int arg) 1829 1862 { 1830 1863 struct kbd_struct *kb = &kbd_table[console]; 1831 - int ret = 0; 1832 - unsigned long flags; 1833 1864 1834 - spin_lock_irqsave(&kbd_event_lock, flags); 1865 + guard(spinlock_irqsave)(&kbd_event_lock); 1835 1866 switch(arg) { 1836 1867 case K_METABIT: 1837 1868 clr_vc_kbd_mode(kb, VC_META); 1838 - break; 1869 + return 0; 1839 1870 case K_ESCPREFIX: 1840 1871 set_vc_kbd_mode(kb, VC_META); 1841 - break; 1872 + return 0; 1842 1873 default: 1843 - ret = -EINVAL; 1874 + return -EINVAL; 1844 1875 } 1845 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1846 - return ret; 1847 1876 } 1848 1877 1849 1878 int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc, int perm) ··· 1868 1905 static unsigned short vt_kdgkbent(unsigned char kbdmode, unsigned char idx, 1869 1906 unsigned char map) 1870 1907 { 1871 - unsigned short *key_map, val; 1872 - unsigned long flags; 1908 + unsigned short *key_map; 1873 1909 1874 1910 /* Ensure another thread doesn't free it under us */ 1875 - spin_lock_irqsave(&kbd_event_lock, flags); 1911 + guard(spinlock_irqsave)(&kbd_event_lock); 1876 1912 key_map = key_maps[map]; 1877 1913 if (key_map) { 1878 - val = U(key_map[idx]); 1914 + unsigned short val = U(key_map[idx]); 1879 1915 if (kbdmode != VC_UNICODE && KTYP(val) >= NR_TYPES) 1880 - val = K_HOLE; 1881 - } else 1882 - val = idx ? K_HOLE : K_NOSUCHMAP; 1883 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1916 + return K_HOLE; 1917 + return val; 1918 + } 1884 1919 1885 - return val; 1920 + return idx ? K_HOLE : K_NOSUCHMAP; 1886 1921 } 1887 1922 1888 1923 static int vt_kdskbent(unsigned char kbdmode, unsigned char idx, 1889 1924 unsigned char map, unsigned short val) 1890 1925 { 1891 - unsigned long flags; 1892 1926 unsigned short *key_map, oldval; 1893 1927 1894 1928 if (!idx && val == K_NOSUCHMAP) { 1895 - spin_lock_irqsave(&kbd_event_lock, flags); 1929 + guard(spinlock_irqsave)(&kbd_event_lock); 1896 1930 /* deallocate map */ 1897 1931 key_map = key_maps[map]; 1898 1932 if (map && key_map) { ··· 1899 1939 keymap_count--; 1900 1940 } 1901 1941 } 1902 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1903 1942 1904 1943 return 0; 1905 1944 } ··· 1920 1961 if (!new_map) 1921 1962 return -ENOMEM; 1922 1963 1923 - spin_lock_irqsave(&kbd_event_lock, flags); 1964 + guard(spinlock_irqsave)(&kbd_event_lock); 1924 1965 key_map = key_maps[map]; 1925 1966 if (key_map == NULL) { 1926 1967 int j; 1927 1968 1928 - if (keymap_count >= MAX_NR_OF_USER_KEYMAPS && 1929 - !capable(CAP_SYS_RESOURCE)) { 1930 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1969 + if (keymap_count >= MAX_NR_OF_USER_KEYMAPS && !capable(CAP_SYS_RESOURCE)) 1931 1970 return -EPERM; 1932 - } 1971 + 1933 1972 key_map = key_maps[map] = no_free_ptr(new_map); 1934 1973 key_map[0] = U(K_ALLOCATED); 1935 1974 for (j = 1; j < NR_KEYS; j++) ··· 1937 1980 1938 1981 oldval = U(key_map[idx]); 1939 1982 if (val == oldval) 1940 - goto out; 1983 + return 0; 1941 1984 1942 1985 /* Attention Key */ 1943 - if ((oldval == K_SAK || val == K_SAK) && !capable(CAP_SYS_ADMIN)) { 1944 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1986 + if ((oldval == K_SAK || val == K_SAK) && !capable(CAP_SYS_ADMIN)) 1945 1987 return -EPERM; 1946 - } 1947 1988 1948 1989 key_map[idx] = U(val); 1949 1990 if (!map && (KTYP(oldval) == KT_SHIFT || KTYP(val) == KT_SHIFT)) 1950 1991 do_compute_shiftstate(); 1951 - out: 1952 - spin_unlock_irqrestore(&kbd_event_lock, flags); 1953 1992 1954 1993 return 0; 1955 1994 } ··· 1991 2038 int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb, int perm) 1992 2039 { 1993 2040 unsigned char kb_func; 1994 - unsigned long flags; 1995 2041 1996 2042 if (get_user(kb_func, &user_kdgkb->kb_func)) 1997 2043 return -EFAULT; ··· 2006 2054 if (!kbs) 2007 2055 return -ENOMEM; 2008 2056 2009 - spin_lock_irqsave(&func_buf_lock, flags); 2010 - len = strscpy(kbs, func_table[kb_func] ? : "", len); 2011 - spin_unlock_irqrestore(&func_buf_lock, flags); 2057 + scoped_guard(spinlock_irqsave, &func_buf_lock) 2058 + len = strscpy(kbs, func_table[kb_func] ? : "", len); 2012 2059 2013 2060 if (len < 0) 2014 2061 return -ENOSPC; ··· 2026 2075 if (IS_ERR(kbs)) 2027 2076 return PTR_ERR(kbs); 2028 2077 2029 - spin_lock_irqsave(&func_buf_lock, flags); 2078 + guard(spinlock_irqsave)(&func_buf_lock); 2030 2079 kbs = vt_kdskbsent(kbs, kb_func); 2031 - spin_unlock_irqrestore(&func_buf_lock, flags); 2032 2080 2033 2081 return 0; 2034 2082 } ··· 2038 2088 int vt_do_kdskled(unsigned int console, int cmd, unsigned long arg, int perm) 2039 2089 { 2040 2090 struct kbd_struct *kb = &kbd_table[console]; 2041 - unsigned long flags; 2042 2091 unsigned char ucval; 2043 2092 2044 2093 switch(cmd) { 2045 2094 /* the ioctls below read/set the flags usually shown in the leds */ 2046 2095 /* don't use them - they will go away without warning */ 2047 2096 case KDGKBLED: 2048 - spin_lock_irqsave(&kbd_event_lock, flags); 2049 - ucval = kb->ledflagstate | (kb->default_ledflagstate << 4); 2050 - spin_unlock_irqrestore(&kbd_event_lock, flags); 2097 + scoped_guard(spinlock_irqsave, &kbd_event_lock) 2098 + ucval = kb->ledflagstate | (kb->default_ledflagstate << 4); 2051 2099 return put_user(ucval, (char __user *)arg); 2052 2100 2053 2101 case KDSKBLED: ··· 2053 2105 return -EPERM; 2054 2106 if (arg & ~0x77) 2055 2107 return -EINVAL; 2056 - spin_lock_irqsave(&led_lock, flags); 2057 - kb->ledflagstate = (arg & 7); 2058 - kb->default_ledflagstate = ((arg >> 4) & 7); 2059 - set_leds(); 2060 - spin_unlock_irqrestore(&led_lock, flags); 2108 + scoped_guard(spinlock_irqsave, &led_lock) { 2109 + kb->ledflagstate = (arg & 7); 2110 + kb->default_ledflagstate = ((arg >> 4) & 7); 2111 + set_leds(); 2112 + } 2061 2113 return 0; 2062 2114 2063 2115 /* the ioctls below only set the lights, not the functions */ ··· 2114 2166 */ 2115 2167 void vt_reset_unicode(unsigned int console) 2116 2168 { 2117 - unsigned long flags; 2118 - 2119 - spin_lock_irqsave(&kbd_event_lock, flags); 2169 + guard(spinlock_irqsave)(&kbd_event_lock); 2120 2170 kbd_table[console].kbdmode = default_utf8 ? VC_UNICODE : VC_XLATE; 2121 - spin_unlock_irqrestore(&kbd_event_lock, flags); 2122 2171 } 2123 2172 2124 2173 /** ··· 2140 2195 void vt_reset_keyboard(unsigned int console) 2141 2196 { 2142 2197 struct kbd_struct *kb = &kbd_table[console]; 2143 - unsigned long flags; 2144 2198 2145 - spin_lock_irqsave(&kbd_event_lock, flags); 2199 + guard(spinlock_irqsave)(&kbd_event_lock); 2146 2200 set_vc_kbd_mode(kb, VC_REPEAT); 2147 2201 clr_vc_kbd_mode(kb, VC_CKMODE); 2148 2202 clr_vc_kbd_mode(kb, VC_APPLIC); 2149 2203 clr_vc_kbd_mode(kb, VC_CRLF); 2150 2204 kb->lockstate = 0; 2151 2205 kb->slockstate = 0; 2152 - spin_lock(&led_lock); 2206 + guard(spinlock)(&led_lock); 2153 2207 kb->ledmode = LED_SHOW_FLAGS; 2154 2208 kb->ledflagstate = kb->default_ledflagstate; 2155 - spin_unlock(&led_lock); 2156 2209 /* do not do set_leds here because this causes an endless tasklet loop 2157 2210 when the keyboard hasn't been initialized yet */ 2158 - spin_unlock_irqrestore(&kbd_event_lock, flags); 2159 2211 } 2160 2212 2161 2213 /** ··· 2182 2240 void vt_set_kbd_mode_bit(unsigned int console, int bit) 2183 2241 { 2184 2242 struct kbd_struct *kb = &kbd_table[console]; 2185 - unsigned long flags; 2186 2243 2187 - spin_lock_irqsave(&kbd_event_lock, flags); 2244 + guard(spinlock_irqsave)(&kbd_event_lock); 2188 2245 set_vc_kbd_mode(kb, bit); 2189 - spin_unlock_irqrestore(&kbd_event_lock, flags); 2190 2246 } 2191 2247 2192 2248 /** ··· 2199 2259 void vt_clr_kbd_mode_bit(unsigned int console, int bit) 2200 2260 { 2201 2261 struct kbd_struct *kb = &kbd_table[console]; 2202 - unsigned long flags; 2203 2262 2204 - spin_lock_irqsave(&kbd_event_lock, flags); 2263 + guard(spinlock_irqsave)(&kbd_event_lock); 2205 2264 clr_vc_kbd_mode(kb, bit); 2206 - spin_unlock_irqrestore(&kbd_event_lock, flags); 2207 2265 }

Configure Feed

Configure Feed