12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716 |
- /*
- * Copyright (C) 1991, 1992 Linus Torvalds
- */
- /*
- * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
- * or rs-channels. It also implements echoing, cooked mode etc.
- *
- * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
- *
- * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
- * tty_struct and tty_queue structures. Previously there was an array
- * of 256 tty_struct's which was statically allocated, and the
- * tty_queue structures were allocated at boot time. Both are now
- * dynamically allocated only when the tty is open.
- *
- * Also restructured routines so that there is more of a separation
- * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
- * the low-level tty routines (serial.c, pty.c, console.c). This
- * makes for cleaner and more compact code. -TYT, 9/17/92
- *
- * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
- * which can be dynamically activated and de-activated by the line
- * discipline handling modules (like SLIP).
- *
- * NOTE: pay no attention to the line discipline code (yet); its
- * interface is still subject to change in this version...
- * -- TYT, 1/31/92
- *
- * Added functionality to the OPOST tty handling. No delays, but all
- * other bits should be there.
- * -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
- *
- * Rewrote canonical mode and added more termios flags.
- * -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
- *
- * Reorganized FASYNC support so mouse code can share it.
- * -- ctm@ardi.com, 9Sep95
- *
- * New TIOCLINUX variants added.
- * -- mj@k332.feld.cvut.cz, 19-Nov-95
- *
- * Restrict vt switching via ioctl()
- * -- grif@cs.ucr.edu, 5-Dec-95
- *
- * Move console and virtual terminal code to more appropriate files,
- * implement CONFIG_VT and generalize console device interface.
- * -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
- *
- * Rewrote tty_init_dev and tty_release_dev to eliminate races.
- * -- Bill Hawes <whawes@star.net>, June 97
- *
- * Added devfs support.
- * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
- *
- * Added support for a Unix98-style ptmx device.
- * -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
- *
- * Reduced memory usage for older ARM systems
- * -- Russell King <rmk@arm.linux.org.uk>
- *
- * Move do_SAK() into process context. Less stack use in devfs functions.
- * alloc_tty_struct() always uses kmalloc()
- * -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
- */
- #include <linux/types.h>
- #include <linux/major.h>
- #include <linux/errno.h>
- #include <linux/signal.h>
- #include <linux/fcntl.h>
- #include <linux/sched.h>
- #include <linux/interrupt.h>
- #include <linux/tty.h>
- #include <linux/tty_driver.h>
- #include <linux/tty_flip.h>
- #include <linux/devpts_fs.h>
- #include <linux/file.h>
- #include <linux/fdtable.h>
- #include <linux/console.h>
- #include <linux/timer.h>
- #include <linux/ctype.h>
- #include <linux/kd.h>
- #include <linux/mm.h>
- #include <linux/string.h>
- #include <linux/slab.h>
- #include <linux/poll.h>
- #include <linux/proc_fs.h>
- #include <linux/init.h>
- #include <linux/module.h>
- #include <linux/device.h>
- #include <linux/wait.h>
- #include <linux/bitops.h>
- #include <linux/delay.h>
- #include <linux/seq_file.h>
- #include <linux/serial.h>
- #include <linux/ratelimit.h>
- #include <linux/uaccess.h>
- #include <linux/kbd_kern.h>
- #include <linux/vt_kern.h>
- #include <linux/selection.h>
- #include <linux/kmod.h>
- #include <linux/nsproxy.h>
- #undef TTY_DEBUG_HANGUP
- #ifdef TTY_DEBUG_HANGUP
- # define tty_debug_hangup(tty, f, args...) tty_debug(tty, f, ##args)
- #else
- # define tty_debug_hangup(tty, f, args...) do { } while (0)
- #endif
- #define TTY_PARANOIA_CHECK 1
- #define CHECK_TTY_COUNT 1
- struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
- .c_iflag = ICRNL | IXON,
- .c_oflag = OPOST | ONLCR,
- .c_cflag = B38400 | CS8 | CREAD | HUPCL,
- .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
- ECHOCTL | ECHOKE | IEXTEN,
- .c_cc = INIT_C_CC,
- .c_ispeed = 38400,
- .c_ospeed = 38400,
- /* .c_line = N_TTY, */
- };
- EXPORT_SYMBOL(tty_std_termios);
- /* This list gets poked at by procfs and various bits of boot up code. This
- could do with some rationalisation such as pulling the tty proc function
- into this file */
- LIST_HEAD(tty_drivers); /* linked list of tty drivers */
- /* Mutex to protect creating and releasing a tty */
- DEFINE_MUTEX(tty_mutex);
- static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
- static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
- ssize_t redirected_tty_write(struct file *, const char __user *,
- size_t, loff_t *);
- static unsigned int tty_poll(struct file *, poll_table *);
- static int tty_open(struct inode *, struct file *);
- long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
- #ifdef CONFIG_COMPAT
- static long tty_compat_ioctl(struct file *file, unsigned int cmd,
- unsigned long arg);
- #else
- #define tty_compat_ioctl NULL
- #endif
- static int __tty_fasync(int fd, struct file *filp, int on);
- static int tty_fasync(int fd, struct file *filp, int on);
- static void release_tty(struct tty_struct *tty, int idx);
- /**
- * free_tty_struct - free a disused tty
- * @tty: tty struct to free
- *
- * Free the write buffers, tty queue and tty memory itself.
- *
- * Locking: none. Must be called after tty is definitely unused
- */
- static void free_tty_struct(struct tty_struct *tty)
- {
- tty_ldisc_deinit(tty);
- put_device(tty->dev);
- kfree(tty->write_buf);
- tty->magic = 0xDEADDEAD;
- kfree(tty);
- }
- static inline struct tty_struct *file_tty(struct file *file)
- {
- return ((struct tty_file_private *)file->private_data)->tty;
- }
- int tty_alloc_file(struct file *file)
- {
- struct tty_file_private *priv;
- priv = kmalloc(sizeof(*priv), GFP_KERNEL);
- if (!priv)
- return -ENOMEM;
- file->private_data = priv;
- return 0;
- }
- /* Associate a new file with the tty structure */
- void tty_add_file(struct tty_struct *tty, struct file *file)
- {
- struct tty_file_private *priv = file->private_data;
- priv->tty = tty;
- priv->file = file;
- spin_lock(&tty->files_lock);
- list_add(&priv->list, &tty->tty_files);
- spin_unlock(&tty->files_lock);
- }
- /**
- * tty_free_file - free file->private_data
- *
- * This shall be used only for fail path handling when tty_add_file was not
- * called yet.
- */
- void tty_free_file(struct file *file)
- {
- struct tty_file_private *priv = file->private_data;
- file->private_data = NULL;
- kfree(priv);
- }
- /* Delete file from its tty */
- static void tty_del_file(struct file *file)
- {
- struct tty_file_private *priv = file->private_data;
- struct tty_struct *tty = priv->tty;
- spin_lock(&tty->files_lock);
- list_del(&priv->list);
- spin_unlock(&tty->files_lock);
- tty_free_file(file);
- }
- /**
- * tty_name - return tty naming
- * @tty: tty structure
- *
- * Convert a tty structure into a name. The name reflects the kernel
- * naming policy and if udev is in use may not reflect user space
- *
- * Locking: none
- */
- const char *tty_name(const struct tty_struct *tty)
- {
- if (!tty) /* Hmm. NULL pointer. That's fun. */
- return "NULL tty";
- return tty->name;
- }
- EXPORT_SYMBOL(tty_name);
- const char *tty_driver_name(const struct tty_struct *tty)
- {
- if (!tty || !tty->driver)
- return "";
- return tty->driver->name;
- }
- static int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
- const char *routine)
- {
- #ifdef TTY_PARANOIA_CHECK
- if (!tty) {
- pr_warn("(%d:%d): %s: NULL tty\n",
- imajor(inode), iminor(inode), routine);
- return 1;
- }
- if (tty->magic != TTY_MAGIC) {
- pr_warn("(%d:%d): %s: bad magic number\n",
- imajor(inode), iminor(inode), routine);
- return 1;
- }
- #endif
- return 0;
- }
- /* Caller must hold tty_lock */
- static int check_tty_count(struct tty_struct *tty, const char *routine)
- {
- #ifdef CHECK_TTY_COUNT
- struct list_head *p;
- int count = 0;
- spin_lock(&tty->files_lock);
- list_for_each(p, &tty->tty_files) {
- count++;
- }
- spin_unlock(&tty->files_lock);
- if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
- tty->driver->subtype == PTY_TYPE_SLAVE &&
- tty->link && tty->link->count)
- count++;
- if (tty->count != count) {
- tty_warn(tty, "%s: tty->count(%d) != #fd's(%d)\n",
- routine, tty->count, count);
- return count;
- }
- #endif
- return 0;
- }
- /**
- * get_tty_driver - find device of a tty
- * @dev_t: device identifier
- * @index: returns the index of the tty
- *
- * This routine returns a tty driver structure, given a device number
- * and also passes back the index number.
- *
- * Locking: caller must hold tty_mutex
- */
- static struct tty_driver *get_tty_driver(dev_t device, int *index)
- {
- struct tty_driver *p;
- list_for_each_entry(p, &tty_drivers, tty_drivers) {
- dev_t base = MKDEV(p->major, p->minor_start);
- if (device < base || device >= base + p->num)
- continue;
- *index = device - base;
- return tty_driver_kref_get(p);
- }
- return NULL;
- }
- #ifdef CONFIG_CONSOLE_POLL
- /**
- * tty_find_polling_driver - find device of a polled tty
- * @name: name string to match
- * @line: pointer to resulting tty line nr
- *
- * This routine returns a tty driver structure, given a name
- * and the condition that the tty driver is capable of polled
- * operation.
- */
- struct tty_driver *tty_find_polling_driver(char *name, int *line)
- {
- struct tty_driver *p, *res = NULL;
- int tty_line = 0;
- int len;
- char *str, *stp;
- for (str = name; *str; str++)
- if ((*str >= '0' && *str <= '9') || *str == ',')
- break;
- if (!*str)
- return NULL;
- len = str - name;
- tty_line = simple_strtoul(str, &str, 10);
- mutex_lock(&tty_mutex);
- /* Search through the tty devices to look for a match */
- list_for_each_entry(p, &tty_drivers, tty_drivers) {
- if (strncmp(name, p->name, len) != 0)
- continue;
- stp = str;
- if (*stp == ',')
- stp++;
- if (*stp == '\0')
- stp = NULL;
- if (tty_line >= 0 && tty_line < p->num && p->ops &&
- p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
- res = tty_driver_kref_get(p);
- *line = tty_line;
- break;
- }
- }
- mutex_unlock(&tty_mutex);
- return res;
- }
- EXPORT_SYMBOL_GPL(tty_find_polling_driver);
- #endif
- static int is_ignored(int sig)
- {
- return (sigismember(¤t->blocked, sig) ||
- current->sighand->action[sig-1].sa.sa_handler == SIG_IGN);
- }
- /**
- * tty_check_change - check for POSIX terminal changes
- * @tty: tty to check
- *
- * If we try to write to, or set the state of, a terminal and we're
- * not in the foreground, send a SIGTTOU. If the signal is blocked or
- * ignored, go ahead and perform the operation. (POSIX 7.2)
- *
- * Locking: ctrl_lock
- */
- int __tty_check_change(struct tty_struct *tty, int sig)
- {
- unsigned long flags;
- struct pid *pgrp, *tty_pgrp;
- int ret = 0;
- if (current->signal->tty != tty)
- return 0;
- rcu_read_lock();
- pgrp = task_pgrp(current);
- spin_lock_irqsave(&tty->ctrl_lock, flags);
- tty_pgrp = tty->pgrp;
- spin_unlock_irqrestore(&tty->ctrl_lock, flags);
- if (tty_pgrp && pgrp != tty->pgrp) {
- if (is_ignored(sig)) {
- if (sig == SIGTTIN)
- ret = -EIO;
- } else if (is_current_pgrp_orphaned())
- ret = -EIO;
- else {
- kill_pgrp(pgrp, sig, 1);
- set_thread_flag(TIF_SIGPENDING);
- ret = -ERESTARTSYS;
- }
- }
- rcu_read_unlock();
- if (!tty_pgrp)
- tty_warn(tty, "sig=%d, tty->pgrp == NULL!\n", sig);
- return ret;
- }
- int tty_check_change(struct tty_struct *tty)
- {
- return __tty_check_change(tty, SIGTTOU);
- }
- EXPORT_SYMBOL(tty_check_change);
- static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
- size_t count, loff_t *ppos)
- {
- return 0;
- }
- static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
- size_t count, loff_t *ppos)
- {
- return -EIO;
- }
- /* No kernel lock held - none needed ;) */
- static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
- {
- return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
- }
- static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
- unsigned long arg)
- {
- return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
- }
- static long hung_up_tty_compat_ioctl(struct file *file,
- unsigned int cmd, unsigned long arg)
- {
- return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
- }
- static int hung_up_tty_fasync(int fd, struct file *file, int on)
- {
- return -ENOTTY;
- }
- static const struct file_operations tty_fops = {
- .llseek = no_llseek,
- .read = tty_read,
- .write = tty_write,
- .poll = tty_poll,
- .unlocked_ioctl = tty_ioctl,
- .compat_ioctl = tty_compat_ioctl,
- .open = tty_open,
- .release = tty_release,
- .fasync = tty_fasync,
- };
- static const struct file_operations console_fops = {
- .llseek = no_llseek,
- .read = tty_read,
- .write = redirected_tty_write,
- .poll = tty_poll,
- .unlocked_ioctl = tty_ioctl,
- .compat_ioctl = tty_compat_ioctl,
- .open = tty_open,
- .release = tty_release,
- .fasync = tty_fasync,
- };
- static const struct file_operations hung_up_tty_fops = {
- .llseek = no_llseek,
- .read = hung_up_tty_read,
- .write = hung_up_tty_write,
- .poll = hung_up_tty_poll,
- .unlocked_ioctl = hung_up_tty_ioctl,
- .compat_ioctl = hung_up_tty_compat_ioctl,
- .release = tty_release,
- .fasync = hung_up_tty_fasync,
- };
- static DEFINE_SPINLOCK(redirect_lock);
- static struct file *redirect;
- void proc_clear_tty(struct task_struct *p)
- {
- unsigned long flags;
- struct tty_struct *tty;
- spin_lock_irqsave(&p->sighand->siglock, flags);
- tty = p->signal->tty;
- p->signal->tty = NULL;
- spin_unlock_irqrestore(&p->sighand->siglock, flags);
- tty_kref_put(tty);
- }
- /**
- * proc_set_tty - set the controlling terminal
- *
- * Only callable by the session leader and only if it does not already have
- * a controlling terminal.
- *
- * Caller must hold: tty_lock()
- * a readlock on tasklist_lock
- * sighand lock
- */
- static void __proc_set_tty(struct tty_struct *tty)
- {
- unsigned long flags;
- spin_lock_irqsave(&tty->ctrl_lock, flags);
- /*
- * The session and fg pgrp references will be non-NULL if
- * tiocsctty() is stealing the controlling tty
- */
- put_pid(tty->session);
- put_pid(tty->pgrp);
- tty->pgrp = get_pid(task_pgrp(current));
- spin_unlock_irqrestore(&tty->ctrl_lock, flags);
- tty->session = get_pid(task_session(current));
- if (current->signal->tty) {
- tty_debug(tty, "current tty %s not NULL!!\n",
- current->signal->tty->name);
- tty_kref_put(current->signal->tty);
- }
- put_pid(current->signal->tty_old_pgrp);
- current->signal->tty = tty_kref_get(tty);
- current->signal->tty_old_pgrp = NULL;
- }
- static void proc_set_tty(struct tty_struct *tty)
- {
- spin_lock_irq(¤t->sighand->siglock);
- __proc_set_tty(tty);
- spin_unlock_irq(¤t->sighand->siglock);
- }
- struct tty_struct *get_current_tty(void)
- {
- struct tty_struct *tty;
- unsigned long flags;
- spin_lock_irqsave(¤t->sighand->siglock, flags);
- tty = tty_kref_get(current->signal->tty);
- spin_unlock_irqrestore(¤t->sighand->siglock, flags);
- return tty;
- }
- EXPORT_SYMBOL_GPL(get_current_tty);
- static void session_clear_tty(struct pid *session)
- {
- struct task_struct *p;
- do_each_pid_task(session, PIDTYPE_SID, p) {
- proc_clear_tty(p);
- } while_each_pid_task(session, PIDTYPE_SID, p);
- }
- /**
- * tty_wakeup - request more data
- * @tty: terminal
- *
- * Internal and external helper for wakeups of tty. This function
- * informs the line discipline if present that the driver is ready
- * to receive more output data.
- */
- void tty_wakeup(struct tty_struct *tty)
- {
- struct tty_ldisc *ld;
- if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
- ld = tty_ldisc_ref(tty);
- if (ld) {
- if (ld->ops->write_wakeup)
- ld->ops->write_wakeup(tty);
- tty_ldisc_deref(ld);
- }
- }
- wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
- }
- EXPORT_SYMBOL_GPL(tty_wakeup);
- /**
- * tty_signal_session_leader - sends SIGHUP to session leader
- * @tty controlling tty
- * @exit_session if non-zero, signal all foreground group processes
- *
- * Send SIGHUP and SIGCONT to the session leader and its process group.
- * Optionally, signal all processes in the foreground process group.
- *
- * Returns the number of processes in the session with this tty
- * as their controlling terminal. This value is used to drop
- * tty references for those processes.
- */
- static int tty_signal_session_leader(struct tty_struct *tty, int exit_session)
- {
- struct task_struct *p;
- int refs = 0;
- struct pid *tty_pgrp = NULL;
- read_lock(&tasklist_lock);
- if (tty->session) {
- do_each_pid_task(tty->session, PIDTYPE_SID, p) {
- spin_lock_irq(&p->sighand->siglock);
- if (p->signal->tty == tty) {
- p->signal->tty = NULL;
- /* We defer the dereferences outside fo
- the tasklist lock */
- refs++;
- }
- if (!p->signal->leader) {
- spin_unlock_irq(&p->sighand->siglock);
- continue;
- }
- __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
- __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
- put_pid(p->signal->tty_old_pgrp); /* A noop */
- spin_lock(&tty->ctrl_lock);
- tty_pgrp = get_pid(tty->pgrp);
- if (tty->pgrp)
- p->signal->tty_old_pgrp = get_pid(tty->pgrp);
- spin_unlock(&tty->ctrl_lock);
- spin_unlock_irq(&p->sighand->siglock);
- } while_each_pid_task(tty->session, PIDTYPE_SID, p);
- }
- read_unlock(&tasklist_lock);
- if (tty_pgrp) {
- if (exit_session)
- kill_pgrp(tty_pgrp, SIGHUP, exit_session);
- put_pid(tty_pgrp);
- }
- return refs;
- }
- /**
- * __tty_hangup - actual handler for hangup events
- * @work: tty device
- *
- * This can be called by a "kworker" kernel thread. That is process
- * synchronous but doesn't hold any locks, so we need to make sure we
- * have the appropriate locks for what we're doing.
- *
- * The hangup event clears any pending redirections onto the hung up
- * device. It ensures future writes will error and it does the needed
- * line discipline hangup and signal delivery. The tty object itself
- * remains intact.
- *
- * Locking:
- * BTM
- * redirect lock for undoing redirection
- * file list lock for manipulating list of ttys
- * tty_ldiscs_lock from called functions
- * termios_rwsem resetting termios data
- * tasklist_lock to walk task list for hangup event
- * ->siglock to protect ->signal/->sighand
- */
- static void __tty_hangup(struct tty_struct *tty, int exit_session)
- {
- struct file *cons_filp = NULL;
- struct file *filp, *f = NULL;
- struct tty_file_private *priv;
- int closecount = 0, n;
- int refs;
- if (!tty)
- return;
- spin_lock(&redirect_lock);
- if (redirect && file_tty(redirect) == tty) {
- f = redirect;
- redirect = NULL;
- }
- spin_unlock(&redirect_lock);
- tty_lock(tty);
- if (test_bit(TTY_HUPPED, &tty->flags)) {
- tty_unlock(tty);
- return;
- }
- /*
- * Some console devices aren't actually hung up for technical and
- * historical reasons, which can lead to indefinite interruptible
- * sleep in n_tty_read(). The following explicitly tells
- * n_tty_read() to abort readers.
- */
- set_bit(TTY_HUPPING, &tty->flags);
- /* inuse_filps is protected by the single tty lock,
- this really needs to change if we want to flush the
- workqueue with the lock held */
- check_tty_count(tty, "tty_hangup");
- spin_lock(&tty->files_lock);
- /* This breaks for file handles being sent over AF_UNIX sockets ? */
- list_for_each_entry(priv, &tty->tty_files, list) {
- filp = priv->file;
- if (filp->f_op->write == redirected_tty_write)
- cons_filp = filp;
- if (filp->f_op->write != tty_write)
- continue;
- closecount++;
- __tty_fasync(-1, filp, 0); /* can't block */
- filp->f_op = &hung_up_tty_fops;
- }
- spin_unlock(&tty->files_lock);
- refs = tty_signal_session_leader(tty, exit_session);
- /* Account for the p->signal references we killed */
- while (refs--)
- tty_kref_put(tty);
- tty_ldisc_hangup(tty, cons_filp != NULL);
- spin_lock_irq(&tty->ctrl_lock);
- clear_bit(TTY_THROTTLED, &tty->flags);
- clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
- put_pid(tty->session);
- put_pid(tty->pgrp);
- tty->session = NULL;
- tty->pgrp = NULL;
- tty->ctrl_status = 0;
- spin_unlock_irq(&tty->ctrl_lock);
- /*
- * If one of the devices matches a console pointer, we
- * cannot just call hangup() because that will cause
- * tty->count and state->count to go out of sync.
- * So we just call close() the right number of times.
- */
- if (cons_filp) {
- if (tty->ops->close)
- for (n = 0; n < closecount; n++)
- tty->ops->close(tty, cons_filp);
- } else if (tty->ops->hangup)
- tty->ops->hangup(tty);
- /*
- * We don't want to have driver/ldisc interactions beyond the ones
- * we did here. The driver layer expects no calls after ->hangup()
- * from the ldisc side, which is now guaranteed.
- */
- set_bit(TTY_HUPPED, &tty->flags);
- clear_bit(TTY_HUPPING, &tty->flags);
- tty_unlock(tty);
- if (f)
- fput(f);
- }
- static void do_tty_hangup(struct work_struct *work)
- {
- struct tty_struct *tty =
- container_of(work, struct tty_struct, hangup_work);
- __tty_hangup(tty, 0);
- }
- /**
- * tty_hangup - trigger a hangup event
- * @tty: tty to hangup
- *
- * A carrier loss (virtual or otherwise) has occurred on this like
- * schedule a hangup sequence to run after this event.
- */
- void tty_hangup(struct tty_struct *tty)
- {
- tty_debug_hangup(tty, "hangup\n");
- schedule_work(&tty->hangup_work);
- }
- EXPORT_SYMBOL(tty_hangup);
- /**
- * tty_vhangup - process vhangup
- * @tty: tty to hangup
- *
- * The user has asked via system call for the terminal to be hung up.
- * We do this synchronously so that when the syscall returns the process
- * is complete. That guarantee is necessary for security reasons.
- */
- void tty_vhangup(struct tty_struct *tty)
- {
- tty_debug_hangup(tty, "vhangup\n");
- __tty_hangup(tty, 0);
- }
- EXPORT_SYMBOL(tty_vhangup);
- /**
- * tty_vhangup_self - process vhangup for own ctty
- *
- * Perform a vhangup on the current controlling tty
- */
- void tty_vhangup_self(void)
- {
- struct tty_struct *tty;
- tty = get_current_tty();
- if (tty) {
- tty_vhangup(tty);
- tty_kref_put(tty);
- }
- }
- /**
- * tty_vhangup_session - hangup session leader exit
- * @tty: tty to hangup
- *
- * The session leader is exiting and hanging up its controlling terminal.
- * Every process in the foreground process group is signalled SIGHUP.
- *
- * We do this synchronously so that when the syscall returns the process
- * is complete. That guarantee is necessary for security reasons.
- */
- static void tty_vhangup_session(struct tty_struct *tty)
- {
- tty_debug_hangup(tty, "session hangup\n");
- __tty_hangup(tty, 1);
- }
- /**
- * tty_hung_up_p - was tty hung up
- * @filp: file pointer of tty
- *
- * Return true if the tty has been subject to a vhangup or a carrier
- * loss
- */
- int tty_hung_up_p(struct file *filp)
- {
- return (filp->f_op == &hung_up_tty_fops);
- }
- EXPORT_SYMBOL(tty_hung_up_p);
- /**
- * disassociate_ctty - disconnect controlling tty
- * @on_exit: true if exiting so need to "hang up" the session
- *
- * This function is typically called only by the session leader, when
- * it wants to disassociate itself from its controlling tty.
- *
- * It performs the following functions:
- * (1) Sends a SIGHUP and SIGCONT to the foreground process group
- * (2) Clears the tty from being controlling the session
- * (3) Clears the controlling tty for all processes in the
- * session group.
- *
- * The argument on_exit is set to 1 if called when a process is
- * exiting; it is 0 if called by the ioctl TIOCNOTTY.
- *
- * Locking:
- * BTM is taken for hysterical raisins, and held when
- * called from no_tty().
- * tty_mutex is taken to protect tty
- * ->siglock is taken to protect ->signal/->sighand
- * tasklist_lock is taken to walk process list for sessions
- * ->siglock is taken to protect ->signal/->sighand
- */
- void disassociate_ctty(int on_exit)
- {
- struct tty_struct *tty;
- if (!current->signal->leader)
- return;
- tty = get_current_tty();
- if (tty) {
- if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY) {
- tty_vhangup_session(tty);
- } else {
- struct pid *tty_pgrp = tty_get_pgrp(tty);
- if (tty_pgrp) {
- kill_pgrp(tty_pgrp, SIGHUP, on_exit);
- if (!on_exit)
- kill_pgrp(tty_pgrp, SIGCONT, on_exit);
- put_pid(tty_pgrp);
- }
- }
- tty_kref_put(tty);
- } else if (on_exit) {
- struct pid *old_pgrp;
- spin_lock_irq(¤t->sighand->siglock);
- old_pgrp = current->signal->tty_old_pgrp;
- current->signal->tty_old_pgrp = NULL;
- spin_unlock_irq(¤t->sighand->siglock);
- if (old_pgrp) {
- kill_pgrp(old_pgrp, SIGHUP, on_exit);
- kill_pgrp(old_pgrp, SIGCONT, on_exit);
- put_pid(old_pgrp);
- }
- return;
- }
- spin_lock_irq(¤t->sighand->siglock);
- put_pid(current->signal->tty_old_pgrp);
- current->signal->tty_old_pgrp = NULL;
- tty = tty_kref_get(current->signal->tty);
- if (tty) {
- unsigned long flags;
- spin_lock_irqsave(&tty->ctrl_lock, flags);
- put_pid(tty->session);
- put_pid(tty->pgrp);
- tty->session = NULL;
- tty->pgrp = NULL;
- spin_unlock_irqrestore(&tty->ctrl_lock, flags);
- tty_kref_put(tty);
- } else
- tty_debug_hangup(tty, "no current tty\n");
- spin_unlock_irq(¤t->sighand->siglock);
- /* Now clear signal->tty under the lock */
- read_lock(&tasklist_lock);
- session_clear_tty(task_session(current));
- read_unlock(&tasklist_lock);
- }
- /**
- *
- * no_tty - Ensure the current process does not have a controlling tty
- */
- void no_tty(void)
- {
- /* FIXME: Review locking here. The tty_lock never covered any race
- between a new association and proc_clear_tty but possible we need
- to protect against this anyway */
- struct task_struct *tsk = current;
- disassociate_ctty(0);
- proc_clear_tty(tsk);
- }
- /**
- * stop_tty - propagate flow control
- * @tty: tty to stop
- *
- * Perform flow control to the driver. May be called
- * on an already stopped device and will not re-call the driver
- * method.
- *
- * This functionality is used by both the line disciplines for
- * halting incoming flow and by the driver. It may therefore be
- * called from any context, may be under the tty atomic_write_lock
- * but not always.
- *
- * Locking:
- * flow_lock
- */
- void __stop_tty(struct tty_struct *tty)
- {
- if (tty->stopped)
- return;
- tty->stopped = 1;
- if (tty->ops->stop)
- tty->ops->stop(tty);
- }
- void stop_tty(struct tty_struct *tty)
- {
- unsigned long flags;
- spin_lock_irqsave(&tty->flow_lock, flags);
- __stop_tty(tty);
- spin_unlock_irqrestore(&tty->flow_lock, flags);
- }
- EXPORT_SYMBOL(stop_tty);
- /**
- * start_tty - propagate flow control
- * @tty: tty to start
- *
- * Start a tty that has been stopped if at all possible. If this
- * tty was previous stopped and is now being started, the driver
- * start method is invoked and the line discipline woken.
- *
- * Locking:
- * flow_lock
- */
- void __start_tty(struct tty_struct *tty)
- {
- if (!tty->stopped || tty->flow_stopped)
- return;
- tty->stopped = 0;
- if (tty->ops->start)
- tty->ops->start(tty);
- tty_wakeup(tty);
- }
- void start_tty(struct tty_struct *tty)
- {
- unsigned long flags;
- spin_lock_irqsave(&tty->flow_lock, flags);
- __start_tty(tty);
- spin_unlock_irqrestore(&tty->flow_lock, flags);
- }
- EXPORT_SYMBOL(start_tty);
- static void tty_update_time(struct timespec *time)
- {
- unsigned long sec = get_seconds();
- /*
- * We only care if the two values differ in anything other than the
- * lower three bits (i.e every 8 seconds). If so, then we can update
- * the time of the tty device, otherwise it could be construded as a
- * security leak to let userspace know the exact timing of the tty.
- */
- if ((sec ^ time->tv_sec) & ~7)
- time->tv_sec = sec;
- }
- /**
- * tty_read - read method for tty device files
- * @file: pointer to tty file
- * @buf: user buffer
- * @count: size of user buffer
- * @ppos: unused
- *
- * Perform the read system call function on this terminal device. Checks
- * for hung up devices before calling the line discipline method.
- *
- * Locking:
- * Locks the line discipline internally while needed. Multiple
- * read calls may be outstanding in parallel.
- */
- static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
- loff_t *ppos)
- {
- int i;
- struct inode *inode = file_inode(file);
- struct tty_struct *tty = file_tty(file);
- struct tty_ldisc *ld;
- if (tty_paranoia_check(tty, inode, "tty_read"))
- return -EIO;
- if (!tty || tty_io_error(tty))
- return -EIO;
- /* We want to wait for the line discipline to sort out in this
- situation */
- ld = tty_ldisc_ref_wait(tty);
- if (!ld)
- return hung_up_tty_read(file, buf, count, ppos);
- if (ld->ops->read)
- i = ld->ops->read(tty, file, buf, count);
- else
- i = -EIO;
- tty_ldisc_deref(ld);
- if (i > 0)
- tty_update_time(&inode->i_atime);
- return i;
- }
- static void tty_write_unlock(struct tty_struct *tty)
- {
- mutex_unlock(&tty->atomic_write_lock);
- wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
- }
- static int tty_write_lock(struct tty_struct *tty, int ndelay)
- {
- if (!mutex_trylock(&tty->atomic_write_lock)) {
- if (ndelay)
- return -EAGAIN;
- if (mutex_lock_interruptible(&tty->atomic_write_lock))
- return -ERESTARTSYS;
- }
- return 0;
- }
- /*
- * Split writes up in sane blocksizes to avoid
- * denial-of-service type attacks
- */
- static inline ssize_t do_tty_write(
- ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
- struct tty_struct *tty,
- struct file *file,
- const char __user *buf,
- size_t count)
- {
- ssize_t ret, written = 0;
- unsigned int chunk;
- ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
- if (ret < 0)
- return ret;
- /*
- * We chunk up writes into a temporary buffer. This
- * simplifies low-level drivers immensely, since they
- * don't have locking issues and user mode accesses.
- *
- * But if TTY_NO_WRITE_SPLIT is set, we should use a
- * big chunk-size..
- *
- * The default chunk-size is 2kB, because the NTTY
- * layer has problems with bigger chunks. It will
- * claim to be able to handle more characters than
- * it actually does.
- *
- * FIXME: This can probably go away now except that 64K chunks
- * are too likely to fail unless switched to vmalloc...
- */
- chunk = 2048;
- if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
- chunk = 65536;
- if (count < chunk)
- chunk = count;
- /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
- if (tty->write_cnt < chunk) {
- unsigned char *buf_chunk;
- if (chunk < 1024)
- chunk = 1024;
- buf_chunk = kmalloc(chunk, GFP_KERNEL);
- if (!buf_chunk) {
- ret = -ENOMEM;
- goto out;
- }
- kfree(tty->write_buf);
- tty->write_cnt = chunk;
- tty->write_buf = buf_chunk;
- }
- /* Do the write .. */
- for (;;) {
- size_t size = count;
- if (size > chunk)
- size = chunk;
- ret = -EFAULT;
- if (copy_from_user(tty->write_buf, buf, size))
- break;
- ret = write(tty, file, tty->write_buf, size);
- if (ret <= 0)
- break;
- written += ret;
- buf += ret;
- count -= ret;
- if (!count)
- break;
- ret = -ERESTARTSYS;
- if (signal_pending(current))
- break;
- cond_resched();
- }
- if (written) {
- tty_update_time(&file_inode(file)->i_mtime);
- ret = written;
- }
- out:
- tty_write_unlock(tty);
- return ret;
- }
- /**
- * tty_write_message - write a message to a certain tty, not just the console.
- * @tty: the destination tty_struct
- * @msg: the message to write
- *
- * This is used for messages that need to be redirected to a specific tty.
- * We don't put it into the syslog queue right now maybe in the future if
- * really needed.
- *
- * We must still hold the BTM and test the CLOSING flag for the moment.
- */
- void tty_write_message(struct tty_struct *tty, char *msg)
- {
- if (tty) {
- mutex_lock(&tty->atomic_write_lock);
- tty_lock(tty);
- if (tty->ops->write && tty->count > 0)
- tty->ops->write(tty, msg, strlen(msg));
- tty_unlock(tty);
- tty_write_unlock(tty);
- }
- return;
- }
- /**
- * tty_write - write method for tty device file
- * @file: tty file pointer
- * @buf: user data to write
- * @count: bytes to write
- * @ppos: unused
- *
- * Write data to a tty device via the line discipline.
- *
- * Locking:
- * Locks the line discipline as required
- * Writes to the tty driver are serialized by the atomic_write_lock
- * and are then processed in chunks to the device. The line discipline
- * write method will not be invoked in parallel for each device.
- */
- static ssize_t tty_write(struct file *file, const char __user *buf,
- size_t count, loff_t *ppos)
- {
- struct tty_struct *tty = file_tty(file);
- struct tty_ldisc *ld;
- ssize_t ret;
- if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
- return -EIO;
- if (!tty || !tty->ops->write || tty_io_error(tty))
- return -EIO;
- /* Short term debug to catch buggy drivers */
- if (tty->ops->write_room == NULL)
- tty_err(tty, "missing write_room method\n");
- ld = tty_ldisc_ref_wait(tty);
- if (!ld)
- return hung_up_tty_write(file, buf, count, ppos);
- if (!ld->ops->write)
- ret = -EIO;
- else
- ret = do_tty_write(ld->ops->write, tty, file, buf, count);
- tty_ldisc_deref(ld);
- return ret;
- }
- ssize_t redirected_tty_write(struct file *file, const char __user *buf,
- size_t count, loff_t *ppos)
- {
- struct file *p = NULL;
- spin_lock(&redirect_lock);
- if (redirect)
- p = get_file(redirect);
- spin_unlock(&redirect_lock);
- if (p) {
- ssize_t res;
- res = vfs_write(p, buf, count, &p->f_pos);
- fput(p);
- return res;
- }
- return tty_write(file, buf, count, ppos);
- }
- /**
- * tty_send_xchar - send priority character
- *
- * Send a high priority character to the tty even if stopped
- *
- * Locking: none for xchar method, write ordering for write method.
- */
- int tty_send_xchar(struct tty_struct *tty, char ch)
- {
- int was_stopped = tty->stopped;
- if (tty->ops->send_xchar) {
- down_read(&tty->termios_rwsem);
- tty->ops->send_xchar(tty, ch);
- up_read(&tty->termios_rwsem);
- return 0;
- }
- if (tty_write_lock(tty, 0) < 0)
- return -ERESTARTSYS;
- down_read(&tty->termios_rwsem);
- if (was_stopped)
- start_tty(tty);
- tty->ops->write(tty, &ch, 1);
- if (was_stopped)
- stop_tty(tty);
- up_read(&tty->termios_rwsem);
- tty_write_unlock(tty);
- return 0;
- }
- static char ptychar[] = "pqrstuvwxyzabcde";
- /**
- * pty_line_name - generate name for a pty
- * @driver: the tty driver in use
- * @index: the minor number
- * @p: output buffer of at least 6 bytes
- *
- * Generate a name from a driver reference and write it to the output
- * buffer.
- *
- * Locking: None
- */
- static void pty_line_name(struct tty_driver *driver, int index, char *p)
- {
- int i = index + driver->name_base;
- /* ->name is initialized to "ttyp", but "tty" is expected */
- sprintf(p, "%s%c%x",
- driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
- ptychar[i >> 4 & 0xf], i & 0xf);
- }
- /**
- * tty_line_name - generate name for a tty
- * @driver: the tty driver in use
- * @index: the minor number
- * @p: output buffer of at least 7 bytes
- *
- * Generate a name from a driver reference and write it to the output
- * buffer.
- *
- * Locking: None
- */
- static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
- {
- if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
- return sprintf(p, "%s", driver->name);
- else
- return sprintf(p, "%s%d", driver->name,
- index + driver->name_base);
- }
- /**
- * tty_driver_lookup_tty() - find an existing tty, if any
- * @driver: the driver for the tty
- * @idx: the minor number
- *
- * Return the tty, if found. If not found, return NULL or ERR_PTR() if the
- * driver lookup() method returns an error.
- *
- * Locking: tty_mutex must be held. If the tty is found, bump the tty kref.
- */
- static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
- struct file *file, int idx)
- {
- struct tty_struct *tty;
- if (driver->ops->lookup)
- tty = driver->ops->lookup(driver, file, idx);
- else
- tty = driver->ttys[idx];
- if (!IS_ERR(tty))
- tty_kref_get(tty);
- return tty;
- }
- /**
- * tty_init_termios - helper for termios setup
- * @tty: the tty to set up
- *
- * Initialise the termios structures for this tty. Thus runs under
- * the tty_mutex currently so we can be relaxed about ordering.
- */
- void tty_init_termios(struct tty_struct *tty)
- {
- struct ktermios *tp;
- int idx = tty->index;
- if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
- tty->termios = tty->driver->init_termios;
- else {
- /* Check for lazy saved data */
- tp = tty->driver->termios[idx];
- if (tp != NULL) {
- tty->termios = *tp;
- tty->termios.c_line = tty->driver->init_termios.c_line;
- } else
- tty->termios = tty->driver->init_termios;
- }
- /* Compatibility until drivers always set this */
- tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
- tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
- }
- EXPORT_SYMBOL_GPL(tty_init_termios);
- int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
- {
- tty_init_termios(tty);
- tty_driver_kref_get(driver);
- tty->count++;
- driver->ttys[tty->index] = tty;
- return 0;
- }
- EXPORT_SYMBOL_GPL(tty_standard_install);
- /**
- * tty_driver_install_tty() - install a tty entry in the driver
- * @driver: the driver for the tty
- * @tty: the tty
- *
- * Install a tty object into the driver tables. The tty->index field
- * will be set by the time this is called. This method is responsible
- * for ensuring any need additional structures are allocated and
- * configured.
- *
- * Locking: tty_mutex for now
- */
- static int tty_driver_install_tty(struct tty_driver *driver,
- struct tty_struct *tty)
- {
- return driver->ops->install ? driver->ops->install(driver, tty) :
- tty_standard_install(driver, tty);
- }
- /**
- * tty_driver_remove_tty() - remove a tty from the driver tables
- * @driver: the driver for the tty
- * @idx: the minor number
- *
- * Remvoe a tty object from the driver tables. The tty->index field
- * will be set by the time this is called.
- *
- * Locking: tty_mutex for now
- */
- static void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
- {
- if (driver->ops->remove)
- driver->ops->remove(driver, tty);
- else
- driver->ttys[tty->index] = NULL;
- }
- /*
- * tty_reopen() - fast re-open of an open tty
- * @tty - the tty to open
- *
- * Return 0 on success, -errno on error.
- * Re-opens on master ptys are not allowed and return -EIO.
- *
- * Locking: Caller must hold tty_lock
- */
- static int tty_reopen(struct tty_struct *tty)
- {
- struct tty_driver *driver = tty->driver;
- if (driver->type == TTY_DRIVER_TYPE_PTY &&
- driver->subtype == PTY_TYPE_MASTER)
- return -EIO;
- if (!tty->count)
- return -EAGAIN;
- if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
- return -EBUSY;
- tty->count++;
- if (!tty->ldisc)
- return tty_ldisc_reinit(tty, tty->termios.c_line);
- return 0;
- }
- /**
- * tty_init_dev - initialise a tty device
- * @driver: tty driver we are opening a device on
- * @idx: device index
- * @ret_tty: returned tty structure
- *
- * Prepare a tty device. This may not be a "new" clean device but
- * could also be an active device. The pty drivers require special
- * handling because of this.
- *
- * Locking:
- * The function is called under the tty_mutex, which
- * protects us from the tty struct or driver itself going away.
- *
- * On exit the tty device has the line discipline attached and
- * a reference count of 1. If a pair was created for pty/tty use
- * and the other was a pty master then it too has a reference count of 1.
- *
- * WSH 06/09/97: Rewritten to remove races and properly clean up after a
- * failed open. The new code protects the open with a mutex, so it's
- * really quite straightforward. The mutex locking can probably be
- * relaxed for the (most common) case of reopening a tty.
- */
- struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
- {
- struct tty_struct *tty;
- int retval;
- /*
- * First time open is complex, especially for PTY devices.
- * This code guarantees that either everything succeeds and the
- * TTY is ready for operation, or else the table slots are vacated
- * and the allocated memory released. (Except that the termios
- * and locked termios may be retained.)
- */
- if (!try_module_get(driver->owner))
- return ERR_PTR(-ENODEV);
- tty = alloc_tty_struct(driver, idx);
- if (!tty) {
- retval = -ENOMEM;
- goto err_module_put;
- }
- tty_lock(tty);
- retval = tty_driver_install_tty(driver, tty);
- if (retval < 0)
- goto err_free_tty;
- if (!tty->port)
- tty->port = driver->ports[idx];
- WARN_RATELIMIT(!tty->port,
- "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
- __func__, tty->driver->name);
- retval = tty_ldisc_lock(tty, 5 * HZ);
- if (retval)
- goto err_release_lock;
- tty->port->itty = tty;
- /*
- * Structures all installed ... call the ldisc open routines.
- * If we fail here just call release_tty to clean up. No need
- * to decrement the use counts, as release_tty doesn't care.
- */
- retval = tty_ldisc_setup(tty, tty->link);
- if (retval)
- goto err_release_tty;
- tty_ldisc_unlock(tty);
- /* Return the tty locked so that it cannot vanish under the caller */
- return tty;
- err_free_tty:
- tty_unlock(tty);
- free_tty_struct(tty);
- err_module_put:
- module_put(driver->owner);
- return ERR_PTR(retval);
- /* call the tty release_tty routine to clean out this slot */
- err_release_tty:
- tty_ldisc_unlock(tty);
- tty_info_ratelimited(tty, "ldisc open failed (%d), clearing slot %d\n",
- retval, idx);
- err_release_lock:
- tty_unlock(tty);
- release_tty(tty, idx);
- return ERR_PTR(retval);
- }
- static void tty_free_termios(struct tty_struct *tty)
- {
- struct ktermios *tp;
- int idx = tty->index;
- /* If the port is going to reset then it has no termios to save */
- if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
- return;
- /* Stash the termios data */
- tp = tty->driver->termios[idx];
- if (tp == NULL) {
- tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
- if (tp == NULL)
- return;
- tty->driver->termios[idx] = tp;
- }
- *tp = tty->termios;
- }
- /**
- * tty_flush_works - flush all works of a tty/pty pair
- * @tty: tty device to flush works for (or either end of a pty pair)
- *
- * Sync flush all works belonging to @tty (and the 'other' tty).
- */
- static void tty_flush_works(struct tty_struct *tty)
- {
- flush_work(&tty->SAK_work);
- flush_work(&tty->hangup_work);
- if (tty->link) {
- flush_work(&tty->link->SAK_work);
- flush_work(&tty->link->hangup_work);
- }
- }
- /**
- * release_one_tty - release tty structure memory
- * @kref: kref of tty we are obliterating
- *
- * Releases memory associated with a tty structure, and clears out the
- * driver table slots. This function is called when a device is no longer
- * in use. It also gets called when setup of a device fails.
- *
- * Locking:
- * takes the file list lock internally when working on the list
- * of ttys that the driver keeps.
- *
- * This method gets called from a work queue so that the driver private
- * cleanup ops can sleep (needed for USB at least)
- */
- static void release_one_tty(struct work_struct *work)
- {
- struct tty_struct *tty =
- container_of(work, struct tty_struct, hangup_work);
- struct tty_driver *driver = tty->driver;
- struct module *owner = driver->owner;
- if (tty->ops->cleanup)
- tty->ops->cleanup(tty);
- tty->magic = 0;
- tty_driver_kref_put(driver);
- module_put(owner);
- spin_lock(&tty->files_lock);
- list_del_init(&tty->tty_files);
- spin_unlock(&tty->files_lock);
- put_pid(tty->pgrp);
- put_pid(tty->session);
- free_tty_struct(tty);
- }
- static void queue_release_one_tty(struct kref *kref)
- {
- struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
- /* The hangup queue is now free so we can reuse it rather than
- waste a chunk of memory for each port */
- INIT_WORK(&tty->hangup_work, release_one_tty);
- schedule_work(&tty->hangup_work);
- }
- /**
- * tty_kref_put - release a tty kref
- * @tty: tty device
- *
- * Release a reference to a tty device and if need be let the kref
- * layer destruct the object for us
- */
- void tty_kref_put(struct tty_struct *tty)
- {
- if (tty)
- kref_put(&tty->kref, queue_release_one_tty);
- }
- EXPORT_SYMBOL(tty_kref_put);
- /**
- * release_tty - release tty structure memory
- *
- * Release both @tty and a possible linked partner (think pty pair),
- * and decrement the refcount of the backing module.
- *
- * Locking:
- * tty_mutex
- * takes the file list lock internally when working on the list
- * of ttys that the driver keeps.
- *
- */
- static void release_tty(struct tty_struct *tty, int idx)
- {
- /* This should always be true but check for the moment */
- WARN_ON(tty->index != idx);
- WARN_ON(!mutex_is_locked(&tty_mutex));
- if (tty->ops->shutdown)
- tty->ops->shutdown(tty);
- tty_free_termios(tty);
- tty_driver_remove_tty(tty->driver, tty);
- tty->port->itty = NULL;
- if (tty->link)
- tty->link->port->itty = NULL;
- tty_buffer_cancel_work(tty->port);
- if (tty->link)
- tty_buffer_cancel_work(tty->link->port);
- tty_kref_put(tty->link);
- tty_kref_put(tty);
- }
- /**
- * tty_release_checks - check a tty before real release
- * @tty: tty to check
- * @o_tty: link of @tty (if any)
- * @idx: index of the tty
- *
- * Performs some paranoid checking before true release of the @tty.
- * This is a no-op unless TTY_PARANOIA_CHECK is defined.
- */
- static int tty_release_checks(struct tty_struct *tty, int idx)
- {
- #ifdef TTY_PARANOIA_CHECK
- if (idx < 0 || idx >= tty->driver->num) {
- tty_debug(tty, "bad idx %d\n", idx);
- return -1;
- }
- /* not much to check for devpts */
- if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
- return 0;
- if (tty != tty->driver->ttys[idx]) {
- tty_debug(tty, "bad driver table[%d] = %p\n",
- idx, tty->driver->ttys[idx]);
- return -1;
- }
- if (tty->driver->other) {
- struct tty_struct *o_tty = tty->link;
- if (o_tty != tty->driver->other->ttys[idx]) {
- tty_debug(tty, "bad other table[%d] = %p\n",
- idx, tty->driver->other->ttys[idx]);
- return -1;
- }
- if (o_tty->link != tty) {
- tty_debug(tty, "bad link = %p\n", o_tty->link);
- return -1;
- }
- }
- #endif
- return 0;
- }
- /**
- * tty_release - vfs callback for close
- * @inode: inode of tty
- * @filp: file pointer for handle to tty
- *
- * Called the last time each file handle is closed that references
- * this tty. There may however be several such references.
- *
- * Locking:
- * Takes bkl. See tty_release_dev
- *
- * Even releasing the tty structures is a tricky business.. We have
- * to be very careful that the structures are all released at the
- * same time, as interrupts might otherwise get the wrong pointers.
- *
- * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
- * lead to double frees or releasing memory still in use.
- */
- int tty_release(struct inode *inode, struct file *filp)
- {
- struct tty_struct *tty = file_tty(filp);
- struct tty_struct *o_tty = NULL;
- int do_sleep, final;
- int idx;
- long timeout = 0;
- int once = 1;
- if (tty_paranoia_check(tty, inode, __func__))
- return 0;
- tty_lock(tty);
- check_tty_count(tty, __func__);
- __tty_fasync(-1, filp, 0);
- idx = tty->index;
- if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
- tty->driver->subtype == PTY_TYPE_MASTER)
- o_tty = tty->link;
- if (tty_release_checks(tty, idx)) {
- tty_unlock(tty);
- return 0;
- }
- tty_debug_hangup(tty, "releasing (count=%d)\n", tty->count);
- if (tty->ops->close)
- tty->ops->close(tty, filp);
- /* If tty is pty master, lock the slave pty (stable lock order) */
- tty_lock_slave(o_tty);
- /*
- * Sanity check: if tty->count is going to zero, there shouldn't be
- * any waiters on tty->read_wait or tty->write_wait. We test the
- * wait queues and kick everyone out _before_ actually starting to
- * close. This ensures that we won't block while releasing the tty
- * structure.
- *
- * The test for the o_tty closing is necessary, since the master and
- * slave sides may close in any order. If the slave side closes out
- * first, its count will be one, since the master side holds an open.
- * Thus this test wouldn't be triggered at the time the slave closed,
- * so we do it now.
- */
- while (1) {
- do_sleep = 0;
- if (tty->count <= 1) {
- if (waitqueue_active(&tty->read_wait)) {
- wake_up_poll(&tty->read_wait, POLLIN);
- do_sleep++;
- }
- if (waitqueue_active(&tty->write_wait)) {
- wake_up_poll(&tty->write_wait, POLLOUT);
- do_sleep++;
- }
- }
- if (o_tty && o_tty->count <= 1) {
- if (waitqueue_active(&o_tty->read_wait)) {
- wake_up_poll(&o_tty->read_wait, POLLIN);
- do_sleep++;
- }
- if (waitqueue_active(&o_tty->write_wait)) {
- wake_up_poll(&o_tty->write_wait, POLLOUT);
- do_sleep++;
- }
- }
- if (!do_sleep)
- break;
- if (once) {
- once = 0;
- tty_warn(tty, "read/write wait queue active!\n");
- }
- schedule_timeout_killable(timeout);
- if (timeout < 120 * HZ)
- timeout = 2 * timeout + 1;
- else
- timeout = MAX_SCHEDULE_TIMEOUT;
- }
- if (o_tty) {
- if (--o_tty->count < 0) {
- tty_warn(tty, "bad slave count (%d)\n", o_tty->count);
- o_tty->count = 0;
- }
- }
- if (--tty->count < 0) {
- tty_warn(tty, "bad tty->count (%d)\n", tty->count);
- tty->count = 0;
- }
- /*
- * We've decremented tty->count, so we need to remove this file
- * descriptor off the tty->tty_files list; this serves two
- * purposes:
- * - check_tty_count sees the correct number of file descriptors
- * associated with this tty.
- * - do_tty_hangup no longer sees this file descriptor as
- * something that needs to be handled for hangups.
- */
- tty_del_file(filp);
- /*
- * Perform some housekeeping before deciding whether to return.
- *
- * If _either_ side is closing, make sure there aren't any
- * processes that still think tty or o_tty is their controlling
- * tty.
- */
- if (!tty->count) {
- read_lock(&tasklist_lock);
- session_clear_tty(tty->session);
- if (o_tty)
- session_clear_tty(o_tty->session);
- read_unlock(&tasklist_lock);
- }
- /* check whether both sides are closing ... */
- final = !tty->count && !(o_tty && o_tty->count);
- tty_unlock_slave(o_tty);
- tty_unlock(tty);
- /* At this point, the tty->count == 0 should ensure a dead tty
- cannot be re-opened by a racing opener */
- if (!final)
- return 0;
- tty_debug_hangup(tty, "final close\n");
- /*
- * Ask the line discipline code to release its structures
- */
- tty_ldisc_release(tty);
- /* Wait for pending work before tty destruction commmences */
- tty_flush_works(tty);
- tty_debug_hangup(tty, "freeing structure\n");
- /*
- * The release_tty function takes care of the details of clearing
- * the slots and preserving the termios structure. The tty_unlock_pair
- * should be safe as we keep a kref while the tty is locked (so the
- * unlock never unlocks a freed tty).
- */
- mutex_lock(&tty_mutex);
- release_tty(tty, idx);
- mutex_unlock(&tty_mutex);
- return 0;
- }
- /**
- * tty_open_current_tty - get locked tty of current task
- * @device: device number
- * @filp: file pointer to tty
- * @return: locked tty of the current task iff @device is /dev/tty
- *
- * Performs a re-open of the current task's controlling tty.
- *
- * We cannot return driver and index like for the other nodes because
- * devpts will not work then. It expects inodes to be from devpts FS.
- */
- static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
- {
- struct tty_struct *tty;
- int retval;
- if (device != MKDEV(TTYAUX_MAJOR, 0))
- return NULL;
- tty = get_current_tty();
- if (!tty)
- return ERR_PTR(-ENXIO);
- filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
- /* noctty = 1; */
- tty_lock(tty);
- tty_kref_put(tty); /* safe to drop the kref now */
- retval = tty_reopen(tty);
- if (retval < 0) {
- tty_unlock(tty);
- tty = ERR_PTR(retval);
- }
- return tty;
- }
- /**
- * tty_lookup_driver - lookup a tty driver for a given device file
- * @device: device number
- * @filp: file pointer to tty
- * @index: index for the device in the @return driver
- * @return: driver for this inode (with increased refcount)
- *
- * If @return is not erroneous, the caller is responsible to decrement the
- * refcount by tty_driver_kref_put.
- *
- * Locking: tty_mutex protects get_tty_driver
- */
- static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
- int *index)
- {
- struct tty_driver *driver;
- switch (device) {
- #ifdef CONFIG_VT
- case MKDEV(TTY_MAJOR, 0): {
- extern struct tty_driver *console_driver;
- driver = tty_driver_kref_get(console_driver);
- *index = fg_console;
- break;
- }
- #endif
- case MKDEV(TTYAUX_MAJOR, 1): {
- struct tty_driver *console_driver = console_device(index);
- if (console_driver) {
- driver = tty_driver_kref_get(console_driver);
- if (driver) {
- /* Don't let /dev/console block */
- filp->f_flags |= O_NONBLOCK;
- break;
- }
- }
- return ERR_PTR(-ENODEV);
- }
- default:
- driver = get_tty_driver(device, index);
- if (!driver)
- return ERR_PTR(-ENODEV);
- break;
- }
- return driver;
- }
- /**
- * tty_open_by_driver - open a tty device
- * @device: dev_t of device to open
- * @inode: inode of device file
- * @filp: file pointer to tty
- *
- * Performs the driver lookup, checks for a reopen, or otherwise
- * performs the first-time tty initialization.
- *
- * Returns the locked initialized or re-opened &tty_struct
- *
- * Claims the global tty_mutex to serialize:
- * - concurrent first-time tty initialization
- * - concurrent tty driver removal w/ lookup
- * - concurrent tty removal from driver table
- */
- static struct tty_struct *tty_open_by_driver(dev_t device, struct inode *inode,
- struct file *filp)
- {
- struct tty_struct *tty;
- struct tty_driver *driver = NULL;
- int index = -1;
- int retval;
- mutex_lock(&tty_mutex);
- driver = tty_lookup_driver(device, filp, &index);
- if (IS_ERR(driver)) {
- mutex_unlock(&tty_mutex);
- return ERR_CAST(driver);
- }
- /* check whether we're reopening an existing tty */
- tty = tty_driver_lookup_tty(driver, filp, index);
- if (IS_ERR(tty)) {
- mutex_unlock(&tty_mutex);
- goto out;
- }
- if (tty) {
- mutex_unlock(&tty_mutex);
- retval = tty_lock_interruptible(tty);
- tty_kref_put(tty); /* drop kref from tty_driver_lookup_tty() */
- if (retval) {
- if (retval == -EINTR)
- retval = -ERESTARTSYS;
- tty = ERR_PTR(retval);
- goto out;
- }
- retval = tty_reopen(tty);
- if (retval < 0) {
- tty_unlock(tty);
- tty = ERR_PTR(retval);
- }
- } else { /* Returns with the tty_lock held for now */
- tty = tty_init_dev(driver, index);
- mutex_unlock(&tty_mutex);
- }
- out:
- tty_driver_kref_put(driver);
- return tty;
- }
- /**
- * tty_open - open a tty device
- * @inode: inode of device file
- * @filp: file pointer to tty
- *
- * tty_open and tty_release keep up the tty count that contains the
- * number of opens done on a tty. We cannot use the inode-count, as
- * different inodes might point to the same tty.
- *
- * Open-counting is needed for pty masters, as well as for keeping
- * track of serial lines: DTR is dropped when the last close happens.
- * (This is not done solely through tty->count, now. - Ted 1/27/92)
- *
- * The termios state of a pty is reset on first open so that
- * settings don't persist across reuse.
- *
- * Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
- * tty->count should protect the rest.
- * ->siglock protects ->signal/->sighand
- *
- * Note: the tty_unlock/lock cases without a ref are only safe due to
- * tty_mutex
- */
- static int tty_open(struct inode *inode, struct file *filp)
- {
- struct tty_struct *tty;
- int noctty, retval;
- dev_t device = inode->i_rdev;
- unsigned saved_flags = filp->f_flags;
- nonseekable_open(inode, filp);
- retry_open:
- retval = tty_alloc_file(filp);
- if (retval)
- return -ENOMEM;
- tty = tty_open_current_tty(device, filp);
- if (!tty)
- tty = tty_open_by_driver(device, inode, filp);
- if (IS_ERR(tty)) {
- tty_free_file(filp);
- retval = PTR_ERR(tty);
- if (retval != -EAGAIN || signal_pending(current))
- return retval;
- schedule();
- goto retry_open;
- }
- tty_add_file(tty, filp);
- check_tty_count(tty, __func__);
- tty_debug_hangup(tty, "opening (count=%d)\n", tty->count);
- if (tty->ops->open)
- retval = tty->ops->open(tty, filp);
- else
- retval = -ENODEV;
- filp->f_flags = saved_flags;
- if (retval) {
- tty_debug_hangup(tty, "open error %d, releasing\n", retval);
- tty_unlock(tty); /* need to call tty_release without BTM */
- tty_release(inode, filp);
- if (retval != -ERESTARTSYS)
- return retval;
- if (signal_pending(current))
- return retval;
- schedule();
- /*
- * Need to reset f_op in case a hangup happened.
- */
- if (tty_hung_up_p(filp))
- filp->f_op = &tty_fops;
- goto retry_open;
- }
- clear_bit(TTY_HUPPED, &tty->flags);
- read_lock(&tasklist_lock);
- spin_lock_irq(¤t->sighand->siglock);
- noctty = (filp->f_flags & O_NOCTTY) ||
- (IS_ENABLED(CONFIG_VT) && device == MKDEV(TTY_MAJOR, 0)) ||
- device == MKDEV(TTYAUX_MAJOR, 1) ||
- (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
- tty->driver->subtype == PTY_TYPE_MASTER);
- if (!noctty &&
- current->signal->leader &&
- !current->signal->tty &&
- tty->session == NULL) {
- /*
- * Don't let a process that only has write access to the tty
- * obtain the privileges associated with having a tty as
- * controlling terminal (being able to reopen it with full
- * access through /dev/tty, being able to perform pushback).
- * Many distributions set the group of all ttys to "tty" and
- * grant write-only access to all terminals for setgid tty
- * binaries, which should not imply full privileges on all ttys.
- *
- * This could theoretically break old code that performs open()
- * on a write-only file descriptor. In that case, it might be
- * necessary to also permit this if
- * inode_permission(inode, MAY_READ) == 0.
- */
- if (filp->f_mode & FMODE_READ)
- __proc_set_tty(tty);
- }
- spin_unlock_irq(¤t->sighand->siglock);
- read_unlock(&tasklist_lock);
- tty_unlock(tty);
- return 0;
- }
- /**
- * tty_poll - check tty status
- * @filp: file being polled
- * @wait: poll wait structures to update
- *
- * Call the line discipline polling method to obtain the poll
- * status of the device.
- *
- * Locking: locks called line discipline but ldisc poll method
- * may be re-entered freely by other callers.
- */
- static unsigned int tty_poll(struct file *filp, poll_table *wait)
- {
- struct tty_struct *tty = file_tty(filp);
- struct tty_ldisc *ld;
- int ret = 0;
- if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
- return 0;
- ld = tty_ldisc_ref_wait(tty);
- if (!ld)
- return hung_up_tty_poll(filp, wait);
- if (ld->ops->poll)
- ret = ld->ops->poll(tty, filp, wait);
- tty_ldisc_deref(ld);
- return ret;
- }
- static int __tty_fasync(int fd, struct file *filp, int on)
- {
- struct tty_struct *tty = file_tty(filp);
- unsigned long flags;
- int retval = 0;
- if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
- goto out;
- retval = fasync_helper(fd, filp, on, &tty->fasync);
- if (retval <= 0)
- goto out;
- if (on) {
- enum pid_type type;
- struct pid *pid;
- spin_lock_irqsave(&tty->ctrl_lock, flags);
- if (tty->pgrp) {
- pid = tty->pgrp;
- type = PIDTYPE_PGID;
- } else {
- pid = task_pid(current);
- type = PIDTYPE_PID;
- }
- get_pid(pid);
- spin_unlock_irqrestore(&tty->ctrl_lock, flags);
- __f_setown(filp, pid, type, 0);
- put_pid(pid);
- retval = 0;
- }
- out:
- return retval;
- }
- static int tty_fasync(int fd, struct file *filp, int on)
- {
- struct tty_struct *tty = file_tty(filp);
- int retval = -ENOTTY;
- tty_lock(tty);
- if (!tty_hung_up_p(filp))
- retval = __tty_fasync(fd, filp, on);
- tty_unlock(tty);
- return retval;
- }
- /**
- * tiocsti - fake input character
- * @tty: tty to fake input into
- * @p: pointer to character
- *
- * Fake input to a tty device. Does the necessary locking and
- * input management.
- *
- * FIXME: does not honour flow control ??
- *
- * Locking:
- * Called functions take tty_ldiscs_lock
- * current->signal->tty check is safe without locks
- *
- * FIXME: may race normal receive processing
- */
- static int tiocsti(struct tty_struct *tty, char __user *p)
- {
- char ch, mbz = 0;
- struct tty_ldisc *ld;
- if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
- return -EPERM;
- if (get_user(ch, p))
- return -EFAULT;
- tty_audit_tiocsti(tty, ch);
- ld = tty_ldisc_ref_wait(tty);
- if (!ld)
- return -EIO;
- ld->ops->receive_buf(tty, &ch, &mbz, 1);
- tty_ldisc_deref(ld);
- return 0;
- }
- /**
- * tiocgwinsz - implement window query ioctl
- * @tty; tty
- * @arg: user buffer for result
- *
- * Copies the kernel idea of the window size into the user buffer.
- *
- * Locking: tty->winsize_mutex is taken to ensure the winsize data
- * is consistent.
- */
- static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
- {
- int err;
- mutex_lock(&tty->winsize_mutex);
- err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
- mutex_unlock(&tty->winsize_mutex);
- return err ? -EFAULT: 0;
- }
- /**
- * tty_do_resize - resize event
- * @tty: tty being resized
- * @rows: rows (character)
- * @cols: cols (character)
- *
- * Update the termios variables and send the necessary signals to
- * peform a terminal resize correctly
- */
- int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
- {
- struct pid *pgrp;
- /* Lock the tty */
- mutex_lock(&tty->winsize_mutex);
- if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
- goto done;
- /* Signal the foreground process group */
- pgrp = tty_get_pgrp(tty);
- if (pgrp)
- kill_pgrp(pgrp, SIGWINCH, 1);
- put_pid(pgrp);
- tty->winsize = *ws;
- done:
- mutex_unlock(&tty->winsize_mutex);
- return 0;
- }
- EXPORT_SYMBOL(tty_do_resize);
- /**
- * tiocswinsz - implement window size set ioctl
- * @tty; tty side of tty
- * @arg: user buffer for result
- *
- * Copies the user idea of the window size to the kernel. Traditionally
- * this is just advisory information but for the Linux console it
- * actually has driver level meaning and triggers a VC resize.
- *
- * Locking:
- * Driver dependent. The default do_resize method takes the
- * tty termios mutex and ctrl_lock. The console takes its own lock
- * then calls into the default method.
- */
- static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
- {
- struct winsize tmp_ws;
- if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
- return -EFAULT;
- if (tty->ops->resize)
- return tty->ops->resize(tty, &tmp_ws);
- else
- return tty_do_resize(tty, &tmp_ws);
- }
- /**
- * tioccons - allow admin to move logical console
- * @file: the file to become console
- *
- * Allow the administrator to move the redirected console device
- *
- * Locking: uses redirect_lock to guard the redirect information
- */
- static int tioccons(struct file *file)
- {
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- if (file->f_op->write == redirected_tty_write) {
- struct file *f;
- spin_lock(&redirect_lock);
- f = redirect;
- redirect = NULL;
- spin_unlock(&redirect_lock);
- if (f)
- fput(f);
- return 0;
- }
- spin_lock(&redirect_lock);
- if (redirect) {
- spin_unlock(&redirect_lock);
- return -EBUSY;
- }
- redirect = get_file(file);
- spin_unlock(&redirect_lock);
- return 0;
- }
- /**
- * fionbio - non blocking ioctl
- * @file: file to set blocking value
- * @p: user parameter
- *
- * Historical tty interfaces had a blocking control ioctl before
- * the generic functionality existed. This piece of history is preserved
- * in the expected tty API of posix OS's.
- *
- * Locking: none, the open file handle ensures it won't go away.
- */
- static int fionbio(struct file *file, int __user *p)
- {
- int nonblock;
- if (get_user(nonblock, p))
- return -EFAULT;
- spin_lock(&file->f_lock);
- if (nonblock)
- file->f_flags |= O_NONBLOCK;
- else
- file->f_flags &= ~O_NONBLOCK;
- spin_unlock(&file->f_lock);
- return 0;
- }
- /**
- * tiocsctty - set controlling tty
- * @tty: tty structure
- * @arg: user argument
- *
- * This ioctl is used to manage job control. It permits a session
- * leader to set this tty as the controlling tty for the session.
- *
- * Locking:
- * Takes tty_lock() to serialize proc_set_tty() for this tty
- * Takes tasklist_lock internally to walk sessions
- * Takes ->siglock() when updating signal->tty
- */
- static int tiocsctty(struct tty_struct *tty, struct file *file, int arg)
- {
- int ret = 0;
- tty_lock(tty);
- read_lock(&tasklist_lock);
- if (current->signal->leader && (task_session(current) == tty->session))
- goto unlock;
- /*
- * The process must be a session leader and
- * not have a controlling tty already.
- */
- if (!current->signal->leader || current->signal->tty) {
- ret = -EPERM;
- goto unlock;
- }
- if (tty->session) {
- /*
- * This tty is already the controlling
- * tty for another session group!
- */
- if (arg == 1 && capable(CAP_SYS_ADMIN)) {
- /*
- * Steal it away
- */
- session_clear_tty(tty->session);
- } else {
- ret = -EPERM;
- goto unlock;
- }
- }
- /* See the comment in tty_open(). */
- if ((file->f_mode & FMODE_READ) == 0 && !capable(CAP_SYS_ADMIN)) {
- ret = -EPERM;
- goto unlock;
- }
- proc_set_tty(tty);
- unlock:
- read_unlock(&tasklist_lock);
- tty_unlock(tty);
- return ret;
- }
- /**
- * tty_get_pgrp - return a ref counted pgrp pid
- * @tty: tty to read
- *
- * Returns a refcounted instance of the pid struct for the process
- * group controlling the tty.
- */
- struct pid *tty_get_pgrp(struct tty_struct *tty)
- {
- unsigned long flags;
- struct pid *pgrp;
- spin_lock_irqsave(&tty->ctrl_lock, flags);
- pgrp = get_pid(tty->pgrp);
- spin_unlock_irqrestore(&tty->ctrl_lock, flags);
- return pgrp;
- }
- EXPORT_SYMBOL_GPL(tty_get_pgrp);
- /*
- * This checks not only the pgrp, but falls back on the pid if no
- * satisfactory pgrp is found. I dunno - gdb doesn't work correctly
- * without this...
- *
- * The caller must hold rcu lock or the tasklist lock.
- */
- static struct pid *session_of_pgrp(struct pid *pgrp)
- {
- struct task_struct *p;
- struct pid *sid = NULL;
- p = pid_task(pgrp, PIDTYPE_PGID);
- if (p == NULL)
- p = pid_task(pgrp, PIDTYPE_PID);
- if (p != NULL)
- sid = task_session(p);
- return sid;
- }
- /**
- * tiocgpgrp - get process group
- * @tty: tty passed by user
- * @real_tty: tty side of the tty passed by the user if a pty else the tty
- * @p: returned pid
- *
- * Obtain the process group of the tty. If there is no process group
- * return an error.
- *
- * Locking: none. Reference to current->signal->tty is safe.
- */
- static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
- {
- struct pid *pid;
- int ret;
- /*
- * (tty == real_tty) is a cheap way of
- * testing if the tty is NOT a master pty.
- */
- if (tty == real_tty && current->signal->tty != real_tty)
- return -ENOTTY;
- pid = tty_get_pgrp(real_tty);
- ret = put_user(pid_vnr(pid), p);
- put_pid(pid);
- return ret;
- }
- /**
- * tiocspgrp - attempt to set process group
- * @tty: tty passed by user
- * @real_tty: tty side device matching tty passed by user
- * @p: pid pointer
- *
- * Set the process group of the tty to the session passed. Only
- * permitted where the tty session is our session.
- *
- * Locking: RCU, ctrl lock
- */
- static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
- {
- struct pid *pgrp;
- pid_t pgrp_nr;
- int retval = tty_check_change(real_tty);
- if (retval == -EIO)
- return -ENOTTY;
- if (retval)
- return retval;
- if (!current->signal->tty ||
- (current->signal->tty != real_tty) ||
- (real_tty->session != task_session(current)))
- return -ENOTTY;
- if (get_user(pgrp_nr, p))
- return -EFAULT;
- if (pgrp_nr < 0)
- return -EINVAL;
- rcu_read_lock();
- pgrp = find_vpid(pgrp_nr);
- retval = -ESRCH;
- if (!pgrp)
- goto out_unlock;
- retval = -EPERM;
- if (session_of_pgrp(pgrp) != task_session(current))
- goto out_unlock;
- retval = 0;
- spin_lock_irq(&tty->ctrl_lock);
- put_pid(real_tty->pgrp);
- real_tty->pgrp = get_pid(pgrp);
- spin_unlock_irq(&tty->ctrl_lock);
- out_unlock:
- rcu_read_unlock();
- return retval;
- }
- /**
- * tiocgsid - get session id
- * @tty: tty passed by user
- * @real_tty: tty side of the tty passed by the user if a pty else the tty
- * @p: pointer to returned session id
- *
- * Obtain the session id of the tty. If there is no session
- * return an error.
- *
- * Locking: none. Reference to current->signal->tty is safe.
- */
- static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
- {
- /*
- * (tty == real_tty) is a cheap way of
- * testing if the tty is NOT a master pty.
- */
- if (tty == real_tty && current->signal->tty != real_tty)
- return -ENOTTY;
- if (!real_tty->session)
- return -ENOTTY;
- return put_user(pid_vnr(real_tty->session), p);
- }
- /**
- * tiocsetd - set line discipline
- * @tty: tty device
- * @p: pointer to user data
- *
- * Set the line discipline according to user request.
- *
- * Locking: see tty_set_ldisc, this function is just a helper
- */
- static int tiocsetd(struct tty_struct *tty, int __user *p)
- {
- int disc;
- int ret;
- if (get_user(disc, p))
- return -EFAULT;
- ret = tty_set_ldisc(tty, disc);
- return ret;
- }
- /**
- * tiocgetd - get line discipline
- * @tty: tty device
- * @p: pointer to user data
- *
- * Retrieves the line discipline id directly from the ldisc.
- *
- * Locking: waits for ldisc reference (in case the line discipline
- * is changing or the tty is being hungup)
- */
- static int tiocgetd(struct tty_struct *tty, int __user *p)
- {
- struct tty_ldisc *ld;
- int ret;
- ld = tty_ldisc_ref_wait(tty);
- if (!ld)
- return -EIO;
- ret = put_user(ld->ops->num, p);
- tty_ldisc_deref(ld);
- return ret;
- }
- /**
- * send_break - performed time break
- * @tty: device to break on
- * @duration: timeout in mS
- *
- * Perform a timed break on hardware that lacks its own driver level
- * timed break functionality.
- *
- * Locking:
- * atomic_write_lock serializes
- *
- */
- static int send_break(struct tty_struct *tty, unsigned int duration)
- {
- int retval;
- if (tty->ops->break_ctl == NULL)
- return 0;
- if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
- retval = tty->ops->break_ctl(tty, duration);
- else {
- /* Do the work ourselves */
- if (tty_write_lock(tty, 0) < 0)
- return -EINTR;
- retval = tty->ops->break_ctl(tty, -1);
- if (retval)
- goto out;
- if (!signal_pending(current))
- msleep_interruptible(duration);
- retval = tty->ops->break_ctl(tty, 0);
- out:
- tty_write_unlock(tty);
- if (signal_pending(current))
- retval = -EINTR;
- }
- return retval;
- }
- /**
- * tty_tiocmget - get modem status
- * @tty: tty device
- * @file: user file pointer
- * @p: pointer to result
- *
- * Obtain the modem status bits from the tty driver if the feature
- * is supported. Return -EINVAL if it is not available.
- *
- * Locking: none (up to the driver)
- */
- static int tty_tiocmget(struct tty_struct *tty, int __user *p)
- {
- int retval = -EINVAL;
- if (tty->ops->tiocmget) {
- retval = tty->ops->tiocmget(tty);
- if (retval >= 0)
- retval = put_user(retval, p);
- }
- return retval;
- }
- /**
- * tty_tiocmset - set modem status
- * @tty: tty device
- * @cmd: command - clear bits, set bits or set all
- * @p: pointer to desired bits
- *
- * Set the modem status bits from the tty driver if the feature
- * is supported. Return -EINVAL if it is not available.
- *
- * Locking: none (up to the driver)
- */
- static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
- unsigned __user *p)
- {
- int retval;
- unsigned int set, clear, val;
- if (tty->ops->tiocmset == NULL)
- return -EINVAL;
- retval = get_user(val, p);
- if (retval)
- return retval;
- set = clear = 0;
- switch (cmd) {
- case TIOCMBIS:
- set = val;
- break;
- case TIOCMBIC:
- clear = val;
- break;
- case TIOCMSET:
- set = val;
- clear = ~val;
- break;
- }
- set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
- clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
- return tty->ops->tiocmset(tty, set, clear);
- }
- static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
- {
- int retval = -EINVAL;
- struct serial_icounter_struct icount;
- memset(&icount, 0, sizeof(icount));
- if (tty->ops->get_icount)
- retval = tty->ops->get_icount(tty, &icount);
- if (retval != 0)
- return retval;
- if (copy_to_user(arg, &icount, sizeof(icount)))
- return -EFAULT;
- return 0;
- }
- static void tty_warn_deprecated_flags(struct serial_struct __user *ss)
- {
- static DEFINE_RATELIMIT_STATE(depr_flags,
- DEFAULT_RATELIMIT_INTERVAL,
- DEFAULT_RATELIMIT_BURST);
- char comm[TASK_COMM_LEN];
- int flags;
- if (get_user(flags, &ss->flags))
- return;
- flags &= ASYNC_DEPRECATED;
- if (flags && __ratelimit(&depr_flags))
- pr_warning("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
- __func__, get_task_comm(comm, current), flags);
- }
- /*
- * if pty, return the slave side (real_tty)
- * otherwise, return self
- */
- static struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
- {
- if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
- tty->driver->subtype == PTY_TYPE_MASTER)
- tty = tty->link;
- return tty;
- }
- /*
- * Split this up, as gcc can choke on it otherwise..
- */
- long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
- {
- struct tty_struct *tty = file_tty(file);
- struct tty_struct *real_tty;
- void __user *p = (void __user *)arg;
- int retval;
- struct tty_ldisc *ld;
- if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
- return -EINVAL;
- real_tty = tty_pair_get_tty(tty);
- /*
- * Factor out some common prep work
- */
- switch (cmd) {
- case TIOCSETD:
- case TIOCSBRK:
- case TIOCCBRK:
- case TCSBRK:
- case TCSBRKP:
- retval = tty_check_change(tty);
- if (retval)
- return retval;
- if (cmd != TIOCCBRK) {
- tty_wait_until_sent(tty, 0);
- if (signal_pending(current))
- return -EINTR;
- }
- break;
- }
- /*
- * Now do the stuff.
- */
- switch (cmd) {
- case TIOCSTI:
- return tiocsti(tty, p);
- case TIOCGWINSZ:
- return tiocgwinsz(real_tty, p);
- case TIOCSWINSZ:
- return tiocswinsz(real_tty, p);
- case TIOCCONS:
- return real_tty != tty ? -EINVAL : tioccons(file);
- case FIONBIO:
- return fionbio(file, p);
- case TIOCEXCL:
- set_bit(TTY_EXCLUSIVE, &tty->flags);
- return 0;
- case TIOCNXCL:
- clear_bit(TTY_EXCLUSIVE, &tty->flags);
- return 0;
- case TIOCGEXCL:
- {
- int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
- return put_user(excl, (int __user *)p);
- }
- case TIOCNOTTY:
- if (current->signal->tty != tty)
- return -ENOTTY;
- no_tty();
- return 0;
- case TIOCSCTTY:
- return tiocsctty(real_tty, file, arg);
- case TIOCGPGRP:
- return tiocgpgrp(tty, real_tty, p);
- case TIOCSPGRP:
- return tiocspgrp(tty, real_tty, p);
- case TIOCGSID:
- return tiocgsid(tty, real_tty, p);
- case TIOCGETD:
- return tiocgetd(tty, p);
- case TIOCSETD:
- return tiocsetd(tty, p);
- case TIOCVHANGUP:
- if (!capable(CAP_SYS_ADMIN))
- return -EPERM;
- tty_vhangup(tty);
- return 0;
- case TIOCGDEV:
- {
- unsigned int ret = new_encode_dev(tty_devnum(real_tty));
- return put_user(ret, (unsigned int __user *)p);
- }
- /*
- * Break handling
- */
- case TIOCSBRK: /* Turn break on, unconditionally */
- if (tty->ops->break_ctl)
- return tty->ops->break_ctl(tty, -1);
- return 0;
- case TIOCCBRK: /* Turn break off, unconditionally */
- if (tty->ops->break_ctl)
- return tty->ops->break_ctl(tty, 0);
- return 0;
- case TCSBRK: /* SVID version: non-zero arg --> no break */
- /* non-zero arg means wait for all output data
- * to be sent (performed above) but don't send break.
- * This is used by the tcdrain() termios function.
- */
- if (!arg)
- return send_break(tty, 250);
- return 0;
- case TCSBRKP: /* support for POSIX tcsendbreak() */
- return send_break(tty, arg ? arg*100 : 250);
- case TIOCMGET:
- return tty_tiocmget(tty, p);
- case TIOCMSET:
- case TIOCMBIC:
- case TIOCMBIS:
- return tty_tiocmset(tty, cmd, p);
- case TIOCGICOUNT:
- retval = tty_tiocgicount(tty, p);
- /* For the moment allow fall through to the old method */
- if (retval != -EINVAL)
- return retval;
- break;
- case TCFLSH:
- switch (arg) {
- case TCIFLUSH:
- case TCIOFLUSH:
- /* flush tty buffer and allow ldisc to process ioctl */
- tty_buffer_flush(tty, NULL);
- break;
- }
- break;
- case TIOCSSERIAL:
- tty_warn_deprecated_flags(p);
- break;
- }
- if (tty->ops->ioctl) {
- retval = tty->ops->ioctl(tty, cmd, arg);
- if (retval != -ENOIOCTLCMD)
- return retval;
- }
- ld = tty_ldisc_ref_wait(tty);
- if (!ld)
- return hung_up_tty_ioctl(file, cmd, arg);
- retval = -EINVAL;
- if (ld->ops->ioctl) {
- retval = ld->ops->ioctl(tty, file, cmd, arg);
- if (retval == -ENOIOCTLCMD)
- retval = -ENOTTY;
- }
- tty_ldisc_deref(ld);
- return retval;
- }
- #ifdef CONFIG_COMPAT
- static long tty_compat_ioctl(struct file *file, unsigned int cmd,
- unsigned long arg)
- {
- struct tty_struct *tty = file_tty(file);
- struct tty_ldisc *ld;
- int retval = -ENOIOCTLCMD;
- if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
- return -EINVAL;
- if (tty->ops->compat_ioctl) {
- retval = tty->ops->compat_ioctl(tty, cmd, arg);
- if (retval != -ENOIOCTLCMD)
- return retval;
- }
- ld = tty_ldisc_ref_wait(tty);
- if (!ld)
- return hung_up_tty_compat_ioctl(file, cmd, arg);
- if (ld->ops->compat_ioctl)
- retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
- else
- retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
- tty_ldisc_deref(ld);
- return retval;
- }
- #endif
- static int this_tty(const void *t, struct file *file, unsigned fd)
- {
- if (likely(file->f_op->read != tty_read))
- return 0;
- return file_tty(file) != t ? 0 : fd + 1;
- }
-
- /*
- * This implements the "Secure Attention Key" --- the idea is to
- * prevent trojan horses by killing all processes associated with this
- * tty when the user hits the "Secure Attention Key". Required for
- * super-paranoid applications --- see the Orange Book for more details.
- *
- * This code could be nicer; ideally it should send a HUP, wait a few
- * seconds, then send a INT, and then a KILL signal. But you then
- * have to coordinate with the init process, since all processes associated
- * with the current tty must be dead before the new getty is allowed
- * to spawn.
- *
- * Now, if it would be correct ;-/ The current code has a nasty hole -
- * it doesn't catch files in flight. We may send the descriptor to ourselves
- * via AF_UNIX socket, close it and later fetch from socket. FIXME.
- *
- * Nasty bug: do_SAK is being called in interrupt context. This can
- * deadlock. We punt it up to process context. AKPM - 16Mar2001
- */
- void __do_SAK(struct tty_struct *tty)
- {
- #ifdef TTY_SOFT_SAK
- tty_hangup(tty);
- #else
- struct task_struct *g, *p;
- struct pid *session;
- int i;
- if (!tty)
- return;
- session = tty->session;
- tty_ldisc_flush(tty);
- tty_driver_flush_buffer(tty);
- read_lock(&tasklist_lock);
- /* Kill the entire session */
- do_each_pid_task(session, PIDTYPE_SID, p) {
- tty_notice(tty, "SAK: killed process %d (%s): by session\n",
- task_pid_nr(p), p->comm);
- send_sig(SIGKILL, p, 1);
- } while_each_pid_task(session, PIDTYPE_SID, p);
- /* Now kill any processes that happen to have the tty open */
- do_each_thread(g, p) {
- if (p->signal->tty == tty) {
- tty_notice(tty, "SAK: killed process %d (%s): by controlling tty\n",
- task_pid_nr(p), p->comm);
- send_sig(SIGKILL, p, 1);
- continue;
- }
- task_lock(p);
- i = iterate_fd(p->files, 0, this_tty, tty);
- if (i != 0) {
- tty_notice(tty, "SAK: killed process %d (%s): by fd#%d\n",
- task_pid_nr(p), p->comm, i - 1);
- force_sig(SIGKILL, p);
- }
- task_unlock(p);
- } while_each_thread(g, p);
- read_unlock(&tasklist_lock);
- #endif
- }
- static void do_SAK_work(struct work_struct *work)
- {
- struct tty_struct *tty =
- container_of(work, struct tty_struct, SAK_work);
- __do_SAK(tty);
- }
- /*
- * The tq handling here is a little racy - tty->SAK_work may already be queued.
- * Fortunately we don't need to worry, because if ->SAK_work is already queued,
- * the values which we write to it will be identical to the values which it
- * already has. --akpm
- */
- void do_SAK(struct tty_struct *tty)
- {
- if (!tty)
- return;
- schedule_work(&tty->SAK_work);
- }
- EXPORT_SYMBOL(do_SAK);
- static int dev_match_devt(struct device *dev, const void *data)
- {
- const dev_t *devt = data;
- return dev->devt == *devt;
- }
- /* Must put_device() after it's unused! */
- static struct device *tty_get_device(struct tty_struct *tty)
- {
- dev_t devt = tty_devnum(tty);
- return class_find_device(tty_class, NULL, &devt, dev_match_devt);
- }
- /**
- * alloc_tty_struct
- *
- * This subroutine allocates and initializes a tty structure.
- *
- * Locking: none - tty in question is not exposed at this point
- */
- struct tty_struct *alloc_tty_struct(struct tty_driver *driver, int idx)
- {
- struct tty_struct *tty;
- tty = kzalloc(sizeof(*tty), GFP_KERNEL);
- if (!tty)
- return NULL;
- kref_init(&tty->kref);
- tty->magic = TTY_MAGIC;
- if (tty_ldisc_init(tty)) {
- kfree(tty);
- return NULL;
- }
- tty->session = NULL;
- tty->pgrp = NULL;
- mutex_init(&tty->legacy_mutex);
- mutex_init(&tty->throttle_mutex);
- init_rwsem(&tty->termios_rwsem);
- mutex_init(&tty->winsize_mutex);
- init_ldsem(&tty->ldisc_sem);
- init_waitqueue_head(&tty->write_wait);
- init_waitqueue_head(&tty->read_wait);
- INIT_WORK(&tty->hangup_work, do_tty_hangup);
- mutex_init(&tty->atomic_write_lock);
- spin_lock_init(&tty->ctrl_lock);
- spin_lock_init(&tty->flow_lock);
- spin_lock_init(&tty->files_lock);
- INIT_LIST_HEAD(&tty->tty_files);
- INIT_WORK(&tty->SAK_work, do_SAK_work);
- tty->driver = driver;
- tty->ops = driver->ops;
- tty->index = idx;
- tty_line_name(driver, idx, tty->name);
- tty->dev = tty_get_device(tty);
- return tty;
- }
- /**
- * tty_put_char - write one character to a tty
- * @tty: tty
- * @ch: character
- *
- * Write one byte to the tty using the provided put_char method
- * if present. Returns the number of characters successfully output.
- *
- * Note: the specific put_char operation in the driver layer may go
- * away soon. Don't call it directly, use this method
- */
- int tty_put_char(struct tty_struct *tty, unsigned char ch)
- {
- if (tty->ops->put_char)
- return tty->ops->put_char(tty, ch);
- return tty->ops->write(tty, &ch, 1);
- }
- EXPORT_SYMBOL_GPL(tty_put_char);
- struct class *tty_class;
- static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
- unsigned int index, unsigned int count)
- {
- int err;
- /* init here, since reused cdevs cause crashes */
- driver->cdevs[index] = cdev_alloc();
- if (!driver->cdevs[index])
- return -ENOMEM;
- driver->cdevs[index]->ops = &tty_fops;
- driver->cdevs[index]->owner = driver->owner;
- err = cdev_add(driver->cdevs[index], dev, count);
- if (err)
- kobject_put(&driver->cdevs[index]->kobj);
- return err;
- }
- /**
- * tty_register_device - register a tty device
- * @driver: the tty driver that describes the tty device
- * @index: the index in the tty driver for this tty device
- * @device: a struct device that is associated with this tty device.
- * This field is optional, if there is no known struct device
- * for this tty device it can be set to NULL safely.
- *
- * Returns a pointer to the struct device for this tty device
- * (or ERR_PTR(-EFOO) on error).
- *
- * This call is required to be made to register an individual tty device
- * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
- * that bit is not set, this function should not be called by a tty
- * driver.
- *
- * Locking: ??
- */
- struct device *tty_register_device(struct tty_driver *driver, unsigned index,
- struct device *device)
- {
- return tty_register_device_attr(driver, index, device, NULL, NULL);
- }
- EXPORT_SYMBOL(tty_register_device);
- static void tty_device_create_release(struct device *dev)
- {
- dev_dbg(dev, "releasing...\n");
- kfree(dev);
- }
- /**
- * tty_register_device_attr - register a tty device
- * @driver: the tty driver that describes the tty device
- * @index: the index in the tty driver for this tty device
- * @device: a struct device that is associated with this tty device.
- * This field is optional, if there is no known struct device
- * for this tty device it can be set to NULL safely.
- * @drvdata: Driver data to be set to device.
- * @attr_grp: Attribute group to be set on device.
- *
- * Returns a pointer to the struct device for this tty device
- * (or ERR_PTR(-EFOO) on error).
- *
- * This call is required to be made to register an individual tty device
- * if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
- * that bit is not set, this function should not be called by a tty
- * driver.
- *
- * Locking: ??
- */
- struct device *tty_register_device_attr(struct tty_driver *driver,
- unsigned index, struct device *device,
- void *drvdata,
- const struct attribute_group **attr_grp)
- {
- char name[64];
- dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
- struct device *dev = NULL;
- int retval = -ENODEV;
- bool cdev = false;
- if (index >= driver->num) {
- pr_err("%s: Attempt to register invalid tty line number (%d)\n",
- driver->name, index);
- return ERR_PTR(-EINVAL);
- }
- if (driver->type == TTY_DRIVER_TYPE_PTY)
- pty_line_name(driver, index, name);
- else
- tty_line_name(driver, index, name);
- if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
- retval = tty_cdev_add(driver, devt, index, 1);
- if (retval)
- goto error;
- cdev = true;
- }
- dev = kzalloc(sizeof(*dev), GFP_KERNEL);
- if (!dev) {
- retval = -ENOMEM;
- goto error;
- }
- dev->devt = devt;
- dev->class = tty_class;
- dev->parent = device;
- dev->release = tty_device_create_release;
- dev_set_name(dev, "%s", name);
- dev->groups = attr_grp;
- dev_set_drvdata(dev, drvdata);
- retval = device_register(dev);
- if (retval)
- goto error;
- return dev;
- error:
- put_device(dev);
- if (cdev) {
- cdev_del(driver->cdevs[index]);
- driver->cdevs[index] = NULL;
- }
- return ERR_PTR(retval);
- }
- EXPORT_SYMBOL_GPL(tty_register_device_attr);
- /**
- * tty_unregister_device - unregister a tty device
- * @driver: the tty driver that describes the tty device
- * @index: the index in the tty driver for this tty device
- *
- * If a tty device is registered with a call to tty_register_device() then
- * this function must be called when the tty device is gone.
- *
- * Locking: ??
- */
- void tty_unregister_device(struct tty_driver *driver, unsigned index)
- {
- device_destroy(tty_class,
- MKDEV(driver->major, driver->minor_start) + index);
- if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
- cdev_del(driver->cdevs[index]);
- driver->cdevs[index] = NULL;
- }
- }
- EXPORT_SYMBOL(tty_unregister_device);
- /**
- * __tty_alloc_driver -- allocate tty driver
- * @lines: count of lines this driver can handle at most
- * @owner: module which is repsonsible for this driver
- * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
- *
- * This should not be called directly, some of the provided macros should be
- * used instead. Use IS_ERR and friends on @retval.
- */
- struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
- unsigned long flags)
- {
- struct tty_driver *driver;
- unsigned int cdevs = 1;
- int err;
- if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
- return ERR_PTR(-EINVAL);
- driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
- if (!driver)
- return ERR_PTR(-ENOMEM);
- kref_init(&driver->kref);
- driver->magic = TTY_DRIVER_MAGIC;
- driver->num = lines;
- driver->owner = owner;
- driver->flags = flags;
- if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
- driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
- GFP_KERNEL);
- driver->termios = kcalloc(lines, sizeof(*driver->termios),
- GFP_KERNEL);
- if (!driver->ttys || !driver->termios) {
- err = -ENOMEM;
- goto err_free_all;
- }
- }
- if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
- driver->ports = kcalloc(lines, sizeof(*driver->ports),
- GFP_KERNEL);
- if (!driver->ports) {
- err = -ENOMEM;
- goto err_free_all;
- }
- cdevs = lines;
- }
- driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
- if (!driver->cdevs) {
- err = -ENOMEM;
- goto err_free_all;
- }
- return driver;
- err_free_all:
- kfree(driver->ports);
- kfree(driver->ttys);
- kfree(driver->termios);
- kfree(driver->cdevs);
- kfree(driver);
- return ERR_PTR(err);
- }
- EXPORT_SYMBOL(__tty_alloc_driver);
- static void destruct_tty_driver(struct kref *kref)
- {
- struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
- int i;
- struct ktermios *tp;
- if (driver->flags & TTY_DRIVER_INSTALLED) {
- /*
- * Free the termios and termios_locked structures because
- * we don't want to get memory leaks when modular tty
- * drivers are removed from the kernel.
- */
- for (i = 0; i < driver->num; i++) {
- tp = driver->termios[i];
- if (tp) {
- driver->termios[i] = NULL;
- kfree(tp);
- }
- if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
- tty_unregister_device(driver, i);
- }
- proc_tty_unregister_driver(driver);
- if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
- cdev_del(driver->cdevs[0]);
- }
- kfree(driver->cdevs);
- kfree(driver->ports);
- kfree(driver->termios);
- kfree(driver->ttys);
- kfree(driver);
- }
- void tty_driver_kref_put(struct tty_driver *driver)
- {
- kref_put(&driver->kref, destruct_tty_driver);
- }
- EXPORT_SYMBOL(tty_driver_kref_put);
- void tty_set_operations(struct tty_driver *driver,
- const struct tty_operations *op)
- {
- driver->ops = op;
- };
- EXPORT_SYMBOL(tty_set_operations);
- void put_tty_driver(struct tty_driver *d)
- {
- tty_driver_kref_put(d);
- }
- EXPORT_SYMBOL(put_tty_driver);
- /*
- * Called by a tty driver to register itself.
- */
- int tty_register_driver(struct tty_driver *driver)
- {
- int error;
- int i;
- dev_t dev;
- struct device *d;
- if (!driver->major) {
- error = alloc_chrdev_region(&dev, driver->minor_start,
- driver->num, driver->name);
- if (!error) {
- driver->major = MAJOR(dev);
- driver->minor_start = MINOR(dev);
- }
- } else {
- dev = MKDEV(driver->major, driver->minor_start);
- error = register_chrdev_region(dev, driver->num, driver->name);
- }
- if (error < 0)
- goto err;
- if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
- error = tty_cdev_add(driver, dev, 0, driver->num);
- if (error)
- goto err_unreg_char;
- }
- mutex_lock(&tty_mutex);
- list_add(&driver->tty_drivers, &tty_drivers);
- mutex_unlock(&tty_mutex);
- if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
- for (i = 0; i < driver->num; i++) {
- d = tty_register_device(driver, i, NULL);
- if (IS_ERR(d)) {
- error = PTR_ERR(d);
- goto err_unreg_devs;
- }
- }
- }
- proc_tty_register_driver(driver);
- driver->flags |= TTY_DRIVER_INSTALLED;
- return 0;
- err_unreg_devs:
- for (i--; i >= 0; i--)
- tty_unregister_device(driver, i);
- mutex_lock(&tty_mutex);
- list_del(&driver->tty_drivers);
- mutex_unlock(&tty_mutex);
- err_unreg_char:
- unregister_chrdev_region(dev, driver->num);
- err:
- return error;
- }
- EXPORT_SYMBOL(tty_register_driver);
- /*
- * Called by a tty driver to unregister itself.
- */
- int tty_unregister_driver(struct tty_driver *driver)
- {
- #if 0
- /* FIXME */
- if (driver->refcount)
- return -EBUSY;
- #endif
- unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
- driver->num);
- mutex_lock(&tty_mutex);
- list_del(&driver->tty_drivers);
- mutex_unlock(&tty_mutex);
- return 0;
- }
- EXPORT_SYMBOL(tty_unregister_driver);
- dev_t tty_devnum(struct tty_struct *tty)
- {
- return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
- }
- EXPORT_SYMBOL(tty_devnum);
- void tty_default_fops(struct file_operations *fops)
- {
- *fops = tty_fops;
- }
- /*
- * Initialize the console device. This is called *early*, so
- * we can't necessarily depend on lots of kernel help here.
- * Just do some early initializations, and do the complex setup
- * later.
- */
- void __init console_init(void)
- {
- initcall_t *call;
- /* Setup the default TTY line discipline. */
- n_tty_init();
- /*
- * set up the console device so that later boot sequences can
- * inform about problems etc..
- */
- call = __con_initcall_start;
- while (call < __con_initcall_end) {
- (*call)();
- call++;
- }
- }
- static char *tty_devnode(struct device *dev, umode_t *mode)
- {
- if (!mode)
- return NULL;
- if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
- dev->devt == MKDEV(TTYAUX_MAJOR, 2))
- *mode = 0666;
- return NULL;
- }
- static int __init tty_class_init(void)
- {
- tty_class = class_create(THIS_MODULE, "tty");
- if (IS_ERR(tty_class))
- return PTR_ERR(tty_class);
- tty_class->devnode = tty_devnode;
- return 0;
- }
- postcore_initcall(tty_class_init);
- /* 3/2004 jmc: why do these devices exist? */
- static struct cdev tty_cdev, console_cdev;
- static ssize_t show_cons_active(struct device *dev,
- struct device_attribute *attr, char *buf)
- {
- struct console *cs[16];
- int i = 0;
- struct console *c;
- ssize_t count = 0;
- console_lock();
- for_each_console(c) {
- if (!c->device)
- continue;
- if (!c->write)
- continue;
- if ((c->flags & CON_ENABLED) == 0)
- continue;
- cs[i++] = c;
- if (i >= ARRAY_SIZE(cs))
- break;
- }
- while (i--) {
- int index = cs[i]->index;
- struct tty_driver *drv = cs[i]->device(cs[i], &index);
- /* don't resolve tty0 as some programs depend on it */
- if (drv && (cs[i]->index > 0 || drv->major != TTY_MAJOR))
- count += tty_line_name(drv, index, buf + count);
- else
- count += sprintf(buf + count, "%s%d",
- cs[i]->name, cs[i]->index);
- count += sprintf(buf + count, "%c", i ? ' ':'\n');
- }
- console_unlock();
- return count;
- }
- static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
- static struct attribute *cons_dev_attrs[] = {
- &dev_attr_active.attr,
- NULL
- };
- ATTRIBUTE_GROUPS(cons_dev);
- static struct device *consdev;
- void console_sysfs_notify(void)
- {
- if (consdev)
- sysfs_notify(&consdev->kobj, NULL, "active");
- }
- /*
- * Ok, now we can initialize the rest of the tty devices and can count
- * on memory allocations, interrupts etc..
- */
- int __init tty_init(void)
- {
- cdev_init(&tty_cdev, &tty_fops);
- if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
- register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
- panic("Couldn't register /dev/tty driver\n");
- device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
- cdev_init(&console_cdev, &console_fops);
- if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
- register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
- panic("Couldn't register /dev/console driver\n");
- consdev = device_create_with_groups(tty_class, NULL,
- MKDEV(TTYAUX_MAJOR, 1), NULL,
- cons_dev_groups, "console");
- if (IS_ERR(consdev))
- consdev = NULL;
- #ifdef CONFIG_VT
- vty_init(&console_fops);
- #endif
- return 0;
- }
|