Doug / smarc-fsl-linux-kernel

1

/*

1

/*

2

3

*/

3

*/

4

5

/*

5

/*

6

* 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles

6

* 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles

7

* or rs-channels. It also implements echoing, cooked mode etc.

7

* or rs-channels. It also implements echoing, cooked mode etc.

8

*

8

*

9

* Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.

9

* Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.

10

*

10

*

11

* Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the

11

* Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the

12

* tty_struct and tty_queue structures. Previously there was an array

12

* tty_struct and tty_queue structures. Previously there was an array

13

* of 256 tty_struct's which was statically allocated, and the

13

* of 256 tty_struct's which was statically allocated, and the

14

* tty_queue structures were allocated at boot time. Both are now

14

* tty_queue structures were allocated at boot time. Both are now

15

* dynamically allocated only when the tty is open.

15

* dynamically allocated only when the tty is open.

16

*

16

*

17

* Also restructured routines so that there is more of a separation

17

* Also restructured routines so that there is more of a separation

18

* between the high-level tty routines (tty_io.c and tty_ioctl.c) and

18

* between the high-level tty routines (tty_io.c and tty_ioctl.c) and

19

* the low-level tty routines (serial.c, pty.c, console.c). This

19

* the low-level tty routines (serial.c, pty.c, console.c). This

20

* makes for cleaner and more compact code. -TYT, 9/17/92

20

* makes for cleaner and more compact code. -TYT, 9/17/92

21

*

21

*

22

* Modified by Fred N. van Kempen, 01/29/93, to add line disciplines

22

* Modified by Fred N. van Kempen, 01/29/93, to add line disciplines

23

* which can be dynamically activated and de-activated by the line

23

* which can be dynamically activated and de-activated by the line

24

* discipline handling modules (like SLIP).

24

* discipline handling modules (like SLIP).

25

*

25

*

26

* NOTE: pay no attention to the line discipline code (yet); its

26

* NOTE: pay no attention to the line discipline code (yet); its

27

* interface is still subject to change in this version...

27

* interface is still subject to change in this version...

28

* -- TYT, 1/31/92

28

* -- TYT, 1/31/92

29

*

29

*

30

* Added functionality to the OPOST tty handling. No delays, but all

30

* Added functionality to the OPOST tty handling. No delays, but all

31

* other bits should be there.

31

* other bits should be there.

32

* -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.

32

* -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.

33

*

33

*

34

* Rewrote canonical mode and added more termios flags.

34

* Rewrote canonical mode and added more termios flags.

35

* -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94

35

* -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94

36

*

36

*

37

* Reorganized FASYNC support so mouse code can share it.

37

* Reorganized FASYNC support so mouse code can share it.

38

* -- ctm@ardi.com, 9Sep95

38

* -- ctm@ardi.com, 9Sep95

39

*

39

*

40

* New TIOCLINUX variants added.

40

* New TIOCLINUX variants added.

41

* -- mj@k332.feld.cvut.cz, 19-Nov-95

41

* -- mj@k332.feld.cvut.cz, 19-Nov-95

42

*

42

*

43

* Restrict vt switching via ioctl()

43

* Restrict vt switching via ioctl()

44

* -- grif@cs.ucr.edu, 5-Dec-95

44

* -- grif@cs.ucr.edu, 5-Dec-95

45

*

45

*

46

* Move console and virtual terminal code to more appropriate files,

46

* Move console and virtual terminal code to more appropriate files,

47

* implement CONFIG_VT and generalize console device interface.

47

* implement CONFIG_VT and generalize console device interface.

48

* -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97

48

* -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97

49

*

49

*

50

* Rewrote tty_init_dev and tty_release_dev to eliminate races.

50

* Rewrote tty_init_dev and tty_release_dev to eliminate races.

51

* -- Bill Hawes <whawes@star.net>, June 97

51

* -- Bill Hawes <whawes@star.net>, June 97

52

*

52

*

53

* Added devfs support.

53

* Added devfs support.

54

* -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998

54

* -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998

55

*

55

*

56

* Added support for a Unix98-style ptmx device.

56

* Added support for a Unix98-style ptmx device.

57

* -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998

57

* -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998

58

*

58

*

59

* Reduced memory usage for older ARM systems

59

* Reduced memory usage for older ARM systems

60

* -- Russell King <rmk@arm.linux.org.uk>

60

* -- Russell King <rmk@arm.linux.org.uk>

61

*

61

*

62

* Move do_SAK() into process context. Less stack use in devfs functions.

62

* Move do_SAK() into process context. Less stack use in devfs functions.

63

* alloc_tty_struct() always uses kmalloc()

63

* alloc_tty_struct() always uses kmalloc()

64

* -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01

64

* -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01

65

*/

65

*/

66

67

#include <linux/types.h>

67

#include <linux/types.h>

68

#include <linux/major.h>

68

#include <linux/major.h>

69

#include <linux/errno.h>

69

#include <linux/errno.h>

70

#include <linux/signal.h>

70

#include <linux/signal.h>

71

#include <linux/fcntl.h>

71

#include <linux/fcntl.h>

72

#include <linux/sched.h>

72

#include <linux/sched.h>

73

#include <linux/interrupt.h>

73

#include <linux/interrupt.h>

74

#include <linux/tty.h>

74

#include <linux/tty.h>

75

#include <linux/tty_driver.h>

75

#include <linux/tty_driver.h>

76

#include <linux/tty_flip.h>

76

#include <linux/tty_flip.h>

77

#include <linux/devpts_fs.h>

77

#include <linux/devpts_fs.h>

78

#include <linux/file.h>

78

#include <linux/file.h>

79

#include <linux/fdtable.h>

79

#include <linux/fdtable.h>

80

#include <linux/console.h>

80

#include <linux/console.h>

81

#include <linux/timer.h>

81

#include <linux/timer.h>

82

#include <linux/ctype.h>

82

#include <linux/ctype.h>

83

#include <linux/kd.h>

83

#include <linux/kd.h>

84

#include <linux/mm.h>

84

#include <linux/mm.h>

85

#include <linux/string.h>

85

#include <linux/string.h>

86

#include <linux/slab.h>

86

#include <linux/slab.h>

87

#include <linux/poll.h>

87

#include <linux/poll.h>

88

#include <linux/proc_fs.h>

88

#include <linux/proc_fs.h>

89

#include <linux/init.h>

89

#include <linux/init.h>

90

#include <linux/module.h>

90

#include <linux/module.h>

91

#include <linux/device.h>

91

#include <linux/device.h>

92

#include <linux/wait.h>

92

#include <linux/wait.h>

93

#include <linux/bitops.h>

93

#include <linux/bitops.h>

94

#include <linux/delay.h>

94

#include <linux/delay.h>

95

#include <linux/seq_file.h>

95

#include <linux/seq_file.h>

96

#include <linux/serial.h>

96

#include <linux/serial.h>

97

#include <linux/ratelimit.h>

97

#include <linux/ratelimit.h>

98

99

#include <linux/uaccess.h>

99

#include <linux/uaccess.h>

100

101

#include <linux/kbd_kern.h>

101

#include <linux/kbd_kern.h>

102

#include <linux/vt_kern.h>

102

#include <linux/vt_kern.h>

103

#include <linux/selection.h>

103

#include <linux/selection.h>

104

105

#include <linux/kmod.h>

105

#include <linux/kmod.h>

106

#include <linux/nsproxy.h>

106

#include <linux/nsproxy.h>

107

108

#undef TTY_DEBUG_HANGUP

108

#undef TTY_DEBUG_HANGUP

109

110

#define TTY_PARANOIA_CHECK 1

110

#define TTY_PARANOIA_CHECK 1

111

#define CHECK_TTY_COUNT 1

111

#define CHECK_TTY_COUNT 1

112

113

struct ktermios tty_std_termios = { /* for the benefit of tty drivers */

113

struct ktermios tty_std_termios = { /* for the benefit of tty drivers */

114

.c_iflag = ICRNL | IXON,

114

.c_iflag = ICRNL | IXON,

115

.c_oflag = OPOST | ONLCR,

115

.c_oflag = OPOST | ONLCR,

116

.c_cflag = B38400 | CS8 | CREAD | HUPCL,

116

.c_cflag = B38400 | CS8 | CREAD | HUPCL,

117

117

118

ECHOCTL | ECHOKE | IEXTEN,

118

ECHOCTL | ECHOKE | IEXTEN,

119

.c_cc = INIT_C_CC,

119

.c_cc = INIT_C_CC,

120

.c_ispeed = 38400,

120

.c_ispeed = 38400,

121

.c_ospeed = 38400

121

.c_ospeed = 38400

122

};

122

};

123

124

EXPORT_SYMBOL(tty_std_termios);

124

EXPORT_SYMBOL(tty_std_termios);

125

126

/* This list gets poked at by procfs and various bits of boot up code. This

126

/* This list gets poked at by procfs and various bits of boot up code. This

127

could do with some rationalisation such as pulling the tty proc function

127

could do with some rationalisation such as pulling the tty proc function

128

into this file */

128

into this file */

129

130

LIST_HEAD(tty_drivers); /* linked list of tty drivers */

130

LIST_HEAD(tty_drivers); /* linked list of tty drivers */

131

132

/* Mutex to protect creating and releasing a tty. This is shared with

132

/* Mutex to protect creating and releasing a tty. This is shared with

133

vt.c for deeply disgusting hack reasons */

133

vt.c for deeply disgusting hack reasons */

134

DEFINE_MUTEX(tty_mutex);

134

DEFINE_MUTEX(tty_mutex);

135

EXPORT_SYMBOL(tty_mutex);

135

EXPORT_SYMBOL(tty_mutex);

136

137

/* Spinlock to protect the tty->tty_files list */

137

/* Spinlock to protect the tty->tty_files list */

138

DEFINE_SPINLOCK(tty_files_lock);

138

DEFINE_SPINLOCK(tty_files_lock);

139

140

static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);

140

static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);

141

static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);

141

static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);

142

ssize_t redirected_tty_write(struct file *, const char __user *,

142

ssize_t redirected_tty_write(struct file *, const char __user *,

143

size_t, loff_t *);

143

size_t, loff_t *);

144

static unsigned int tty_poll(struct file *, poll_table *);

144

static unsigned int tty_poll(struct file *, poll_table *);

145

static int tty_open(struct inode *, struct file *);

145

static int tty_open(struct inode *, struct file *);

146

long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

146

long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

147

#ifdef CONFIG_COMPAT

147

#ifdef CONFIG_COMPAT

148

static long tty_compat_ioctl(struct file *file, unsigned int cmd,

148

static long tty_compat_ioctl(struct file *file, unsigned int cmd,

149

unsigned long arg);

149

unsigned long arg);

150

#else

150

#else

151

#define tty_compat_ioctl NULL

151

#define tty_compat_ioctl NULL

152

#endif

152

#endif

153

static int __tty_fasync(int fd, struct file *filp, int on);

153

static int __tty_fasync(int fd, struct file *filp, int on);

154

static int tty_fasync(int fd, struct file *filp, int on);

154

static int tty_fasync(int fd, struct file *filp, int on);

155

static void release_tty(struct tty_struct *tty, int idx);

155

static void release_tty(struct tty_struct *tty, int idx);

156

static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);

156

static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);

157

static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);

157

static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);

158

159

/**

159

/**

160

* alloc_tty_struct - allocate a tty object

160

* alloc_tty_struct - allocate a tty object

161

*

161

*

162

* Return a new empty tty structure. The data fields have not

162

* Return a new empty tty structure. The data fields have not

163

* been initialized in any way but has been zeroed

163

* been initialized in any way but has been zeroed

164

*

164

*

165

* Locking: none

165

* Locking: none

166

*/

166

*/

167

168

struct tty_struct *alloc_tty_struct(void)

168

struct tty_struct *alloc_tty_struct(void)

169

{

169

{

170

return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);

170

return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);

171

}

171

}

172

173

/**

173

/**

174

* free_tty_struct - free a disused tty

174

* free_tty_struct - free a disused tty

175

* @tty: tty struct to free

175

* @tty: tty struct to free

176

*

176

*

177

* Free the write buffers, tty queue and tty memory itself.

177

* Free the write buffers, tty queue and tty memory itself.

178

*

178

*

179

* Locking: none. Must be called after tty is definitely unused

179

* Locking: none. Must be called after tty is definitely unused

180

*/

180

*/

181

182

void free_tty_struct(struct tty_struct *tty)

182

void free_tty_struct(struct tty_struct *tty)

183

{

183

{

184

if (!tty)

184

if (!tty)

185

return;

185

return;

186

if (tty->dev)

186

if (tty->dev)

187

put_device(tty->dev);

187

put_device(tty->dev);

188

kfree(tty->write_buf);

188

kfree(tty->write_buf);

189

tty->magic = 0xDEADDEAD;

189

tty->magic = 0xDEADDEAD;

190

kfree(tty);

190

kfree(tty);

191

}

191

}

192

193

static inline struct tty_struct *file_tty(struct file *file)

193

static inline struct tty_struct *file_tty(struct file *file)

194

{

194

{

195

return ((struct tty_file_private *)file->private_data)->tty;

195

return ((struct tty_file_private *)file->private_data)->tty;

196

}

196

}

197

198

int tty_alloc_file(struct file *file)

198

int tty_alloc_file(struct file *file)

199

{

199

{

200

struct tty_file_private *priv;

200

struct tty_file_private *priv;

201

202

priv = kmalloc(sizeof(*priv), GFP_KERNEL);

202

priv = kmalloc(sizeof(*priv), GFP_KERNEL);

203

if (!priv)

203

if (!priv)

204

return -ENOMEM;

204

return -ENOMEM;

205

206

file->private_data = priv;

206

file->private_data = priv;

207

208

return 0;

208

return 0;

209

}

209

}

210

211

/* Associate a new file with the tty structure */

211

/* Associate a new file with the tty structure */

212

void tty_add_file(struct tty_struct *tty, struct file *file)

212

void tty_add_file(struct tty_struct *tty, struct file *file)

213

{

213

{

214

struct tty_file_private *priv = file->private_data;

214

struct tty_file_private *priv = file->private_data;

215

216

priv->tty = tty;

216

priv->tty = tty;

217

priv->file = file;

217

priv->file = file;

218

219

spin_lock(&tty_files_lock);

219

spin_lock(&tty_files_lock);

220

list_add(&priv->list, &tty->tty_files);

220

list_add(&priv->list, &tty->tty_files);

221

spin_unlock(&tty_files_lock);

221

spin_unlock(&tty_files_lock);

222

}

222

}

223

224

/**

224

/**

225

* tty_free_file - free file->private_data

225

* tty_free_file - free file->private_data

226

*

226

*

227

* This shall be used only for fail path handling when tty_add_file was not

227

* This shall be used only for fail path handling when tty_add_file was not

228

* called yet.

228

* called yet.

229

*/

229

*/

230

void tty_free_file(struct file *file)

230

void tty_free_file(struct file *file)

231

{

231

{

232

struct tty_file_private *priv = file->private_data;

232

struct tty_file_private *priv = file->private_data;

233

234

file->private_data = NULL;

234

file->private_data = NULL;

235

kfree(priv);

235

kfree(priv);

236

}

236

}

237

238

/* Delete file from its tty */

238

/* Delete file from its tty */

239

void tty_del_file(struct file *file)

239

void tty_del_file(struct file *file)

240

{

240

{

241

struct tty_file_private *priv = file->private_data;

241

struct tty_file_private *priv = file->private_data;

242

243

spin_lock(&tty_files_lock);

243

spin_lock(&tty_files_lock);

244

list_del(&priv->list);

244

list_del(&priv->list);

245

spin_unlock(&tty_files_lock);

245

spin_unlock(&tty_files_lock);

246

tty_free_file(file);

246

tty_free_file(file);

247

}

247

}

248

249

250

#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)

250

#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)

251

252

/**

252

/**

253

* tty_name - return tty naming

253

* tty_name - return tty naming

254

* @tty: tty structure

254

* @tty: tty structure

255

* @buf: buffer for output

255

* @buf: buffer for output

256

*

256

*

257

* Convert a tty structure into a name. The name reflects the kernel

257

* Convert a tty structure into a name. The name reflects the kernel

258

* naming policy and if udev is in use may not reflect user space

258

* naming policy and if udev is in use may not reflect user space

259

*

259

*

260

* Locking: none

260

* Locking: none

261

*/

261

*/

262

263

char *tty_name(struct tty_struct *tty, char *buf)

263

char *tty_name(struct tty_struct *tty, char *buf)

264

{

264

{

265

if (!tty) /* Hmm. NULL pointer. That's fun. */

265

if (!tty) /* Hmm. NULL pointer. That's fun. */

266

strcpy(buf, "NULL tty");

266

strcpy(buf, "NULL tty");

267

else

267

else

268

strcpy(buf, tty->name);

268

strcpy(buf, tty->name);

269

return buf;

269

return buf;

270

}

270

}

271

272

EXPORT_SYMBOL(tty_name);

272

EXPORT_SYMBOL(tty_name);

273

274

int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,

274

int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,

275

const char *routine)

275

const char *routine)

276

{

276

{

277

#ifdef TTY_PARANOIA_CHECK

277

#ifdef TTY_PARANOIA_CHECK

278

if (!tty) {

278

if (!tty) {

279

printk(KERN_WARNING

279

printk(KERN_WARNING

280

"null TTY for (%d:%d) in %s\n",

280

"null TTY for (%d:%d) in %s\n",

281

imajor(inode), iminor(inode), routine);

281

imajor(inode), iminor(inode), routine);

282

return 1;

282

return 1;

283

}

283

}

284

if (tty->magic != TTY_MAGIC) {

284

if (tty->magic != TTY_MAGIC) {

285

printk(KERN_WARNING

285

printk(KERN_WARNING

286

"bad magic number for tty struct (%d:%d) in %s\n",

286

"bad magic number for tty struct (%d:%d) in %s\n",

287

imajor(inode), iminor(inode), routine);

287

imajor(inode), iminor(inode), routine);

288

return 1;

288

return 1;

289

}

289

}

290

#endif

290

#endif

291

return 0;

291

return 0;

292

}

292

}

293

294

static int check_tty_count(struct tty_struct *tty, const char *routine)

294

static int check_tty_count(struct tty_struct *tty, const char *routine)

295

{

295

{

296

#ifdef CHECK_TTY_COUNT

296

#ifdef CHECK_TTY_COUNT

297

struct list_head *p;

297

struct list_head *p;

298

int count = 0;

298

int count = 0;

299

300

spin_lock(&tty_files_lock);

300

spin_lock(&tty_files_lock);

301

list_for_each(p, &tty->tty_files) {

301

list_for_each(p, &tty->tty_files) {

302

count++;

302

count++;

303

}

303

}

304

spin_unlock(&tty_files_lock);

304

spin_unlock(&tty_files_lock);

305

if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&

305

if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&

306

tty->driver->subtype == PTY_TYPE_SLAVE &&

306

tty->driver->subtype == PTY_TYPE_SLAVE &&

307

tty->link && tty->link->count)

307

tty->link && tty->link->count)

308

count++;

308

count++;

309

if (tty->count != count) {

309

if (tty->count != count) {

310

printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "

310

printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "

311

"!= #fd's(%d) in %s\n",

311

"!= #fd's(%d) in %s\n",

312

tty->name, tty->count, count, routine);

312

tty->name, tty->count, count, routine);

313

return count;

313

return count;

314

}

314

}

315

#endif

315

#endif

316

return 0;

316

return 0;

317

}

317

}

318

319

/**

319

/**

320

* get_tty_driver - find device of a tty

320

* get_tty_driver - find device of a tty

321

* @dev_t: device identifier

321

* @dev_t: device identifier

322

* @index: returns the index of the tty

322

* @index: returns the index of the tty

323

*

323

*

324

* This routine returns a tty driver structure, given a device number

324

* This routine returns a tty driver structure, given a device number

325

* and also passes back the index number.

325

* and also passes back the index number.

326

*

326

*

327

* Locking: caller must hold tty_mutex

327

* Locking: caller must hold tty_mutex

328

*/

328

*/

329

330

static struct tty_driver *get_tty_driver(dev_t device, int *index)

330

static struct tty_driver *get_tty_driver(dev_t device, int *index)

331

{

331

{

332

struct tty_driver *p;

332

struct tty_driver *p;

333

334

list_for_each_entry(p, &tty_drivers, tty_drivers) {

334

list_for_each_entry(p, &tty_drivers, tty_drivers) {

335

dev_t base = MKDEV(p->major, p->minor_start);

335

dev_t base = MKDEV(p->major, p->minor_start);

336

if (device < base || device >= base + p->num)

336

if (device < base || device >= base + p->num)

337

continue;

337

continue;

338

*index = device - base;

338

*index = device - base;

339

return tty_driver_kref_get(p);

339

return tty_driver_kref_get(p);

340

}

340

}

341

return NULL;

341

return NULL;

342

}

342

}

343

344

#ifdef CONFIG_CONSOLE_POLL

344

#ifdef CONFIG_CONSOLE_POLL

345

346

/**

346

/**

347

* tty_find_polling_driver - find device of a polled tty

347

* tty_find_polling_driver - find device of a polled tty

348

* @name: name string to match

348

* @name: name string to match

349

* @line: pointer to resulting tty line nr

349

* @line: pointer to resulting tty line nr

350

*

350

*

351

* This routine returns a tty driver structure, given a name

351

* This routine returns a tty driver structure, given a name

352

* and the condition that the tty driver is capable of polled

352

* and the condition that the tty driver is capable of polled

353

* operation.

353

* operation.

354

*/

354

*/

355

struct tty_driver *tty_find_polling_driver(char *name, int *line)

355

struct tty_driver *tty_find_polling_driver(char *name, int *line)

356

{

356

{

357

struct tty_driver *p, *res = NULL;

357

struct tty_driver *p, *res = NULL;

358

int tty_line = 0;

358

int tty_line = 0;

359

int len;

359

int len;

360

char *str, *stp;

360

char *str, *stp;

361

362

for (str = name; *str; str++)

362

for (str = name; *str; str++)

363

if ((*str >= '0' && *str <= '9') || *str == ',')

363

if ((*str >= '0' && *str <= '9') || *str == ',')

364

break;

364

break;

365

if (!*str)

365

if (!*str)

366

return NULL;

366

return NULL;

367

368

len = str - name;

368

len = str - name;

369

tty_line = simple_strtoul(str, &str, 10);

369

tty_line = simple_strtoul(str, &str, 10);

370

371

mutex_lock(&tty_mutex);

371

mutex_lock(&tty_mutex);

372

/* Search through the tty devices to look for a match */

372

/* Search through the tty devices to look for a match */

373

list_for_each_entry(p, &tty_drivers, tty_drivers) {

373

list_for_each_entry(p, &tty_drivers, tty_drivers) {

374

if (strncmp(name, p->name, len) != 0)

374

if (strncmp(name, p->name, len) != 0)

375

continue;

375

continue;

376

stp = str;

376

stp = str;

377

if (*stp == ',')

377

if (*stp == ',')

378

stp++;

378

stp++;

379

if (*stp == '\0')

379

if (*stp == '\0')

380

stp = NULL;

380

stp = NULL;

381

382

if (tty_line >= 0 && tty_line < p->num && p->ops &&

382

if (tty_line >= 0 && tty_line < p->num && p->ops &&

383

p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {

383

p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {

384

res = tty_driver_kref_get(p);

384

res = tty_driver_kref_get(p);

385

*line = tty_line;

385

*line = tty_line;

386

break;

386

break;

387

}

387

}

388

}

388

}

389

mutex_unlock(&tty_mutex);

389

mutex_unlock(&tty_mutex);

390

391

return res;

391

return res;

392

}

392

}

393

EXPORT_SYMBOL_GPL(tty_find_polling_driver);

393

EXPORT_SYMBOL_GPL(tty_find_polling_driver);

394

#endif

394

#endif

395

396

/**

396

/**

397

* tty_check_change - check for POSIX terminal changes

397

* tty_check_change - check for POSIX terminal changes

398

* @tty: tty to check

398

* @tty: tty to check

399

*

399

*

400

* If we try to write to, or set the state of, a terminal and we're

400

* If we try to write to, or set the state of, a terminal and we're

401

* not in the foreground, send a SIGTTOU. If the signal is blocked or

401

* not in the foreground, send a SIGTTOU. If the signal is blocked or

402

* ignored, go ahead and perform the operation. (POSIX 7.2)

402

* ignored, go ahead and perform the operation. (POSIX 7.2)

403

*

403

*

404

* Locking: ctrl_lock

404

* Locking: ctrl_lock

405

*/

405

*/

406

407

int tty_check_change(struct tty_struct *tty)

407

int tty_check_change(struct tty_struct *tty)

408

{

408

{

409

unsigned long flags;

409

unsigned long flags;

410

int ret = 0;

410

int ret = 0;

411

412

if (current->signal->tty != tty)

412

if (current->signal->tty != tty)

413

return 0;

413

return 0;

414

415

spin_lock_irqsave(&tty->ctrl_lock, flags);

415

spin_lock_irqsave(&tty->ctrl_lock, flags);

416

417

if (!tty->pgrp) {

417

if (!tty->pgrp) {

418

printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");

418

printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");

419

goto out_unlock;

419

goto out_unlock;

420

}

420

}

421

if (task_pgrp(current) == tty->pgrp)

421

if (task_pgrp(current) == tty->pgrp)

422

goto out_unlock;

422

goto out_unlock;

423

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

423

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

424

if (is_ignored(SIGTTOU))

424

if (is_ignored(SIGTTOU))

425

goto out;

425

goto out;

426

if (is_current_pgrp_orphaned()) {

426

if (is_current_pgrp_orphaned()) {

427

ret = -EIO;

427

ret = -EIO;

428

goto out;

428

goto out;

429

}

429

}

430

kill_pgrp(task_pgrp(current), SIGTTOU, 1);

430

kill_pgrp(task_pgrp(current), SIGTTOU, 1);

431

set_thread_flag(TIF_SIGPENDING);

431

set_thread_flag(TIF_SIGPENDING);

432

ret = -ERESTARTSYS;

432

ret = -ERESTARTSYS;

433

out:

433

out:

434

return ret;

434

return ret;

435

out_unlock:

435

out_unlock:

436

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

436

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

437

return ret;

437

return ret;

438

}

438

}

439

440

EXPORT_SYMBOL(tty_check_change);

440

EXPORT_SYMBOL(tty_check_change);

441

442

static ssize_t hung_up_tty_read(struct file *file, char __user *buf,

442

static ssize_t hung_up_tty_read(struct file *file, char __user *buf,

443

size_t count, loff_t *ppos)

443

size_t count, loff_t *ppos)

444

{

444

{

445

return 0;

445

return 0;

446

}

446

}

447

448

static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,

448

static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,

449

size_t count, loff_t *ppos)

449

size_t count, loff_t *ppos)

450

{

450

{

451

return -EIO;

451

return -EIO;

452

}

452

}

453

454

/* No kernel lock held - none needed ;) */

454

/* No kernel lock held - none needed ;) */

455

static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)

455

static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)

456

{

456

{

457

457

458

}

458

}

459

460

static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,

460

static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,

461

unsigned long arg)

461

unsigned long arg)

462

{

462

{

463

return cmd == TIOCSPGRP ? -ENOTTY : -EIO;

463

return cmd == TIOCSPGRP ? -ENOTTY : -EIO;

464

}

464

}

465

466

static long hung_up_tty_compat_ioctl(struct file *file,

466

static long hung_up_tty_compat_ioctl(struct file *file,

467

unsigned int cmd, unsigned long arg)

467

unsigned int cmd, unsigned long arg)

468

{

468

{

469

return cmd == TIOCSPGRP ? -ENOTTY : -EIO;

469

return cmd == TIOCSPGRP ? -ENOTTY : -EIO;

470

}

470

}

471

472

static const struct file_operations tty_fops = {

472

static const struct file_operations tty_fops = {

473

.llseek = no_llseek,

473

.llseek = no_llseek,

474

.read = tty_read,

474

.read = tty_read,

475

.write = tty_write,

475

.write = tty_write,

476

.poll = tty_poll,

476

.poll = tty_poll,

477

.unlocked_ioctl = tty_ioctl,

477

.unlocked_ioctl = tty_ioctl,

478

.compat_ioctl = tty_compat_ioctl,

478

.compat_ioctl = tty_compat_ioctl,

479

.open = tty_open,

479

.open = tty_open,

480

.release = tty_release,

480

.release = tty_release,

481

.fasync = tty_fasync,

481

.fasync = tty_fasync,

482

};

482

};

483

484

static const struct file_operations console_fops = {

484

static const struct file_operations console_fops = {

485

.llseek = no_llseek,

485

.llseek = no_llseek,

486

.read = tty_read,

486

.read = tty_read,

487

.write = redirected_tty_write,

487

.write = redirected_tty_write,

488

.poll = tty_poll,

488

.poll = tty_poll,

489

.unlocked_ioctl = tty_ioctl,

489

.unlocked_ioctl = tty_ioctl,

490

.compat_ioctl = tty_compat_ioctl,

490

.compat_ioctl = tty_compat_ioctl,

491

.open = tty_open,

491

.open = tty_open,

492

.release = tty_release,

492

.release = tty_release,

493

.fasync = tty_fasync,

493

.fasync = tty_fasync,

494

};

494

};

495

496

static const struct file_operations hung_up_tty_fops = {

496

static const struct file_operations hung_up_tty_fops = {

497

.llseek = no_llseek,

497

.llseek = no_llseek,

498

.read = hung_up_tty_read,

498

.read = hung_up_tty_read,

499

.write = hung_up_tty_write,

499

.write = hung_up_tty_write,

500

.poll = hung_up_tty_poll,

500

.poll = hung_up_tty_poll,

501

.unlocked_ioctl = hung_up_tty_ioctl,

501

.unlocked_ioctl = hung_up_tty_ioctl,

502

.compat_ioctl = hung_up_tty_compat_ioctl,

502

.compat_ioctl = hung_up_tty_compat_ioctl,

503

.release = tty_release,

503

.release = tty_release,

504

};

504

};

505

506

static DEFINE_SPINLOCK(redirect_lock);

506

static DEFINE_SPINLOCK(redirect_lock);

507

static struct file *redirect;

507

static struct file *redirect;

508

509

/**

509

/**

510

* tty_wakeup - request more data

510

* tty_wakeup - request more data

511

* @tty: terminal

511

* @tty: terminal

512

*

512

*

513

* Internal and external helper for wakeups of tty. This function

513

* Internal and external helper for wakeups of tty. This function

514

* informs the line discipline if present that the driver is ready

514

* informs the line discipline if present that the driver is ready

515

* to receive more output data.

515

* to receive more output data.

516

*/

516

*/

517

518

void tty_wakeup(struct tty_struct *tty)

518

void tty_wakeup(struct tty_struct *tty)

519

{

519

{

520

struct tty_ldisc *ld;

520

struct tty_ldisc *ld;

521

522

if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {

522

if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {

523

ld = tty_ldisc_ref(tty);

523

ld = tty_ldisc_ref(tty);

524

if (ld) {

524

if (ld) {

525

if (ld->ops->write_wakeup)

525

if (ld->ops->write_wakeup)

526

ld->ops->write_wakeup(tty);

526

ld->ops->write_wakeup(tty);

527

tty_ldisc_deref(ld);

527

tty_ldisc_deref(ld);

528

}

528

}

529

}

529

}

530

wake_up_interruptible_poll(&tty->write_wait, POLLOUT);

530

wake_up_interruptible_poll(&tty->write_wait, POLLOUT);

531

}

531

}

532

533

EXPORT_SYMBOL_GPL(tty_wakeup);

533

EXPORT_SYMBOL_GPL(tty_wakeup);

534

535

/**

535

/**

536

* __tty_hangup - actual handler for hangup events

536

* __tty_hangup - actual handler for hangup events

537

* @work: tty device

537

* @work: tty device

538

*

538

*

539

* This can be called by the "eventd" kernel thread. That is process

539

* This can be called by the "eventd" kernel thread. That is process

540

* synchronous but doesn't hold any locks, so we need to make sure we

540

* synchronous but doesn't hold any locks, so we need to make sure we

541

* have the appropriate locks for what we're doing.

541

* have the appropriate locks for what we're doing.

542

*

542

*

543

* The hangup event clears any pending redirections onto the hung up

543

* The hangup event clears any pending redirections onto the hung up

544

* device. It ensures future writes will error and it does the needed

544

* device. It ensures future writes will error and it does the needed

545

* line discipline hangup and signal delivery. The tty object itself

545

* line discipline hangup and signal delivery. The tty object itself

546

* remains intact.

546

* remains intact.

547

*

547

*

548

* Locking:

548

* Locking:

549

* BTM

549

* BTM

550

* redirect lock for undoing redirection

550

* redirect lock for undoing redirection

551

* file list lock for manipulating list of ttys

551

* file list lock for manipulating list of ttys

552

* tty_ldisc_lock from called functions

552

* tty_ldisc_lock from called functions

553

* termios_mutex resetting termios data

553

* termios_mutex resetting termios data

554

* tasklist_lock to walk task list for hangup event

554

* tasklist_lock to walk task list for hangup event

555

* ->siglock to protect ->signal/->sighand

555

* ->siglock to protect ->signal/->sighand

556

*/

556

*/

557

void __tty_hangup(struct tty_struct *tty)

557

void __tty_hangup(struct tty_struct *tty)

558

{

558

{

559

struct file *cons_filp = NULL;

559

struct file *cons_filp = NULL;

560

struct file *filp, *f = NULL;

560

struct file *filp, *f = NULL;

561

struct task_struct *p;

561

struct task_struct *p;

562

struct tty_file_private *priv;

562

struct tty_file_private *priv;

563

int closecount = 0, n;

563

int closecount = 0, n;

564

unsigned long flags;

564

unsigned long flags;

565

int refs = 0;

565

int refs = 0;

566

567

if (!tty)

567

if (!tty)

568

return;

568

return;

569

570

571

spin_lock(&redirect_lock);

571

spin_lock(&redirect_lock);

572

if (redirect && file_tty(redirect) == tty) {

572

if (redirect && file_tty(redirect) == tty) {

573

f = redirect;

573

f = redirect;

574

redirect = NULL;

574

redirect = NULL;

575

}

575

}

576

spin_unlock(&redirect_lock);

576

spin_unlock(&redirect_lock);

577

578

tty_lock(tty);

578

tty_lock(tty);

579

580

/* some functions below drop BTM, so we need this bit */

580

/* some functions below drop BTM, so we need this bit */

581

set_bit(TTY_HUPPING, &tty->flags);

581

set_bit(TTY_HUPPING, &tty->flags);

582

583

/* inuse_filps is protected by the single tty lock,

583

/* inuse_filps is protected by the single tty lock,

584

this really needs to change if we want to flush the

584

this really needs to change if we want to flush the

585

workqueue with the lock held */

585

workqueue with the lock held */

586

check_tty_count(tty, "tty_hangup");

586

check_tty_count(tty, "tty_hangup");

587

588

spin_lock(&tty_files_lock);

588

spin_lock(&tty_files_lock);

589

/* This breaks for file handles being sent over AF_UNIX sockets ? */

589

/* This breaks for file handles being sent over AF_UNIX sockets ? */

590

list_for_each_entry(priv, &tty->tty_files, list) {

590

list_for_each_entry(priv, &tty->tty_files, list) {

591

filp = priv->file;

591

filp = priv->file;

592

if (filp->f_op->write == redirected_tty_write)

592

if (filp->f_op->write == redirected_tty_write)

593

cons_filp = filp;

593

cons_filp = filp;

594

if (filp->f_op->write != tty_write)

594

if (filp->f_op->write != tty_write)

595

continue;

595

continue;

596

closecount++;

596

closecount++;

597

__tty_fasync(-1, filp, 0); /* can't block */

597

__tty_fasync(-1, filp, 0); /* can't block */

598

filp->f_op = &hung_up_tty_fops;

598

filp->f_op = &hung_up_tty_fops;

599

}

599

}

600

spin_unlock(&tty_files_lock);

600

spin_unlock(&tty_files_lock);

601

602

/*

602

/*

603

* it drops BTM and thus races with reopen

603

* it drops BTM and thus races with reopen

604

* we protect the race by TTY_HUPPING

604

* we protect the race by TTY_HUPPING

605

*/

605

*/

606

tty_ldisc_hangup(tty);

606

tty_ldisc_hangup(tty);

607

608

read_lock(&tasklist_lock);

608

read_lock(&tasklist_lock);

609

if (tty->session) {

609

if (tty->session) {

610

do_each_pid_task(tty->session, PIDTYPE_SID, p) {

610

do_each_pid_task(tty->session, PIDTYPE_SID, p) {

611

spin_lock_irq(&p->sighand->siglock);

611

spin_lock_irq(&p->sighand->siglock);

612

if (p->signal->tty == tty) {

612

if (p->signal->tty == tty) {

613

p->signal->tty = NULL;

613

p->signal->tty = NULL;

614

/* We defer the dereferences outside fo

614

/* We defer the dereferences outside fo

615

the tasklist lock */

615

the tasklist lock */

616

refs++;

616

refs++;

617

}

617

}

618

if (!p->signal->leader) {

618

if (!p->signal->leader) {

619

spin_unlock_irq(&p->sighand->siglock);

619

spin_unlock_irq(&p->sighand->siglock);

620

continue;

620

continue;

621

}

621

}

622

__group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);

622

__group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);

623

__group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);

623

__group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);

624

put_pid(p->signal->tty_old_pgrp); /* A noop */

624

put_pid(p->signal->tty_old_pgrp); /* A noop */

625

spin_lock_irqsave(&tty->ctrl_lock, flags);

625

spin_lock_irqsave(&tty->ctrl_lock, flags);

626

if (tty->pgrp)

626

if (tty->pgrp)

627

p->signal->tty_old_pgrp = get_pid(tty->pgrp);

627

p->signal->tty_old_pgrp = get_pid(tty->pgrp);

628

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

628

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

629

spin_unlock_irq(&p->sighand->siglock);

629

spin_unlock_irq(&p->sighand->siglock);

630

} while_each_pid_task(tty->session, PIDTYPE_SID, p);

630

} while_each_pid_task(tty->session, PIDTYPE_SID, p);

631

}

631

}

632

read_unlock(&tasklist_lock);

632

read_unlock(&tasklist_lock);

633

634

spin_lock_irqsave(&tty->ctrl_lock, flags);

634

spin_lock_irqsave(&tty->ctrl_lock, flags);

635

clear_bit(TTY_THROTTLED, &tty->flags);

635

clear_bit(TTY_THROTTLED, &tty->flags);

636

clear_bit(TTY_PUSH, &tty->flags);

636

clear_bit(TTY_PUSH, &tty->flags);

637

clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);

637

clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);

638

put_pid(tty->session);

638

put_pid(tty->session);

639

put_pid(tty->pgrp);

639

put_pid(tty->pgrp);

640

tty->session = NULL;

640

tty->session = NULL;

641

tty->pgrp = NULL;

641

tty->pgrp = NULL;

642

tty->ctrl_status = 0;

642

tty->ctrl_status = 0;

643

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

643

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

644

645

/* Account for the p->signal references we killed */

645

/* Account for the p->signal references we killed */

646

while (refs--)

646

while (refs--)

647

tty_kref_put(tty);

647

tty_kref_put(tty);

648

649

/*

649

/*

650

* If one of the devices matches a console pointer, we

650

* If one of the devices matches a console pointer, we

651

* cannot just call hangup() because that will cause

651

* cannot just call hangup() because that will cause

652

* tty->count and state->count to go out of sync.

652

* tty->count and state->count to go out of sync.

653

* So we just call close() the right number of times.

653

* So we just call close() the right number of times.

654

*/

654

*/

655

if (cons_filp) {

655

if (cons_filp) {

656

if (tty->ops->close)

656

if (tty->ops->close)

657

for (n = 0; n < closecount; n++)

657

for (n = 0; n < closecount; n++)

658

tty->ops->close(tty, cons_filp);

658

tty->ops->close(tty, cons_filp);

659

} else if (tty->ops->hangup)

659

} else if (tty->ops->hangup)

660

(tty->ops->hangup)(tty);

660

(tty->ops->hangup)(tty);

661

/*

661

/*

662

* We don't want to have driver/ldisc interactions beyond

662

* We don't want to have driver/ldisc interactions beyond

663

* the ones we did here. The driver layer expects no

663

* the ones we did here. The driver layer expects no

664

* calls after ->hangup() from the ldisc side. However we

664

* calls after ->hangup() from the ldisc side. However we

665

* can't yet guarantee all that.

665

* can't yet guarantee all that.

666

*/

666

*/

667

set_bit(TTY_HUPPED, &tty->flags);

667

set_bit(TTY_HUPPED, &tty->flags);

668

clear_bit(TTY_HUPPING, &tty->flags);

668

clear_bit(TTY_HUPPING, &tty->flags);

669

tty_ldisc_enable(tty);

669

tty_ldisc_enable(tty);

670

671

tty_unlock(tty);

671

tty_unlock(tty);

672

673

if (f)

673

if (f)

674

fput(f);

674

fput(f);

675

}

675

}

676

677

static void do_tty_hangup(struct work_struct *work)

677

static void do_tty_hangup(struct work_struct *work)

678

{

678

{

679

struct tty_struct *tty =

679

struct tty_struct *tty =

680

container_of(work, struct tty_struct, hangup_work);

680

container_of(work, struct tty_struct, hangup_work);

681

682

__tty_hangup(tty);

682

__tty_hangup(tty);

683

}

683

}

684

685

/**

685

/**

686

* tty_hangup - trigger a hangup event

686

* tty_hangup - trigger a hangup event

687

* @tty: tty to hangup

687

* @tty: tty to hangup

688

*

688

*

689

* A carrier loss (virtual or otherwise) has occurred on this like

689

* A carrier loss (virtual or otherwise) has occurred on this like

690

* schedule a hangup sequence to run after this event.

690

* schedule a hangup sequence to run after this event.

691

*/

691

*/

692

693

void tty_hangup(struct tty_struct *tty)

693

void tty_hangup(struct tty_struct *tty)

694

{

694

{

695

#ifdef TTY_DEBUG_HANGUP

695

#ifdef TTY_DEBUG_HANGUP

696

char buf[64];

696

char buf[64];

697

printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));

697

printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));

698

#endif

698

#endif

699

schedule_work(&tty->hangup_work);

699

schedule_work(&tty->hangup_work);

700

}

700

}

701

702

EXPORT_SYMBOL(tty_hangup);

702

EXPORT_SYMBOL(tty_hangup);

703

704

/**

704

/**

705

* tty_vhangup - process vhangup

705

* tty_vhangup - process vhangup

706

* @tty: tty to hangup

706

* @tty: tty to hangup

707

*

707

*

708

* The user has asked via system call for the terminal to be hung up.

708

* The user has asked via system call for the terminal to be hung up.

709

* We do this synchronously so that when the syscall returns the process

709

* We do this synchronously so that when the syscall returns the process

710

* is complete. That guarantee is necessary for security reasons.

710

* is complete. That guarantee is necessary for security reasons.

711

*/

711

*/

712

713

void tty_vhangup(struct tty_struct *tty)

713

void tty_vhangup(struct tty_struct *tty)

714

{

714

{

715

#ifdef TTY_DEBUG_HANGUP

715

#ifdef TTY_DEBUG_HANGUP

716

char buf[64];

716

char buf[64];

717

718

printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));

718

printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));

719

#endif

719

#endif

720

__tty_hangup(tty);

720

__tty_hangup(tty);

721

}

721

}

722

723

EXPORT_SYMBOL(tty_vhangup);

723

EXPORT_SYMBOL(tty_vhangup);

724

725

726

/**

726

/**

727

* tty_vhangup_self - process vhangup for own ctty

727

* tty_vhangup_self - process vhangup for own ctty

728

*

728

*

729

* Perform a vhangup on the current controlling tty

729

* Perform a vhangup on the current controlling tty

730

*/

730

*/

731

732

void tty_vhangup_self(void)

732

void tty_vhangup_self(void)

733

{

733

{

734

struct tty_struct *tty;

734

struct tty_struct *tty;

735

736

tty = get_current_tty();

736

tty = get_current_tty();

737

if (tty) {

737

if (tty) {

738

tty_vhangup(tty);

738

tty_vhangup(tty);

739

tty_kref_put(tty);

739

tty_kref_put(tty);

740

}

740

}

741

}

741

}

742

743

/**

743

/**

744

* tty_hung_up_p - was tty hung up

744

* tty_hung_up_p - was tty hung up

745

* @filp: file pointer of tty

745

* @filp: file pointer of tty

746

*

746

*

747

* Return true if the tty has been subject to a vhangup or a carrier

747

* Return true if the tty has been subject to a vhangup or a carrier

748

* loss

748

* loss

749

*/

749

*/

750

751

int tty_hung_up_p(struct file *filp)

751

int tty_hung_up_p(struct file *filp)

752

{

752

{

753

return (filp->f_op == &hung_up_tty_fops);

753

return (filp->f_op == &hung_up_tty_fops);

754

}

754

}

755

756

EXPORT_SYMBOL(tty_hung_up_p);

756

EXPORT_SYMBOL(tty_hung_up_p);

757

758

static void session_clear_tty(struct pid *session)

758

static void session_clear_tty(struct pid *session)

759

{

759

{

760

struct task_struct *p;

760

struct task_struct *p;

761

do_each_pid_task(session, PIDTYPE_SID, p) {

761

do_each_pid_task(session, PIDTYPE_SID, p) {

762

proc_clear_tty(p);

762

proc_clear_tty(p);

763

} while_each_pid_task(session, PIDTYPE_SID, p);

763

} while_each_pid_task(session, PIDTYPE_SID, p);

764

}

764

}

765

766

/**

766

/**

767

* disassociate_ctty - disconnect controlling tty

767

* disassociate_ctty - disconnect controlling tty

768

* @on_exit: true if exiting so need to "hang up" the session

768

* @on_exit: true if exiting so need to "hang up" the session

769

*

769

*

770

* This function is typically called only by the session leader, when

770

* This function is typically called only by the session leader, when

771

* it wants to disassociate itself from its controlling tty.

771

* it wants to disassociate itself from its controlling tty.

772

*

772

*

773

* It performs the following functions:

773

* It performs the following functions:

774

* (1) Sends a SIGHUP and SIGCONT to the foreground process group

774

* (1) Sends a SIGHUP and SIGCONT to the foreground process group

775

* (2) Clears the tty from being controlling the session

775

* (2) Clears the tty from being controlling the session

776

* (3) Clears the controlling tty for all processes in the

776

* (3) Clears the controlling tty for all processes in the

777

* session group.

777

* session group.

778

*

778

*

779

* The argument on_exit is set to 1 if called when a process is

779

* The argument on_exit is set to 1 if called when a process is

780

* exiting; it is 0 if called by the ioctl TIOCNOTTY.

780

* exiting; it is 0 if called by the ioctl TIOCNOTTY.

781

*

781

*

782

* Locking:

782

* Locking:

783

* BTM is taken for hysterical raisins, and held when

783

* BTM is taken for hysterical raisins, and held when

784

* called from no_tty().

784

* called from no_tty().

785

* tty_mutex is taken to protect tty

785

* tty_mutex is taken to protect tty

786

* ->siglock is taken to protect ->signal/->sighand

786

* ->siglock is taken to protect ->signal/->sighand

787

* tasklist_lock is taken to walk process list for sessions

787

* tasklist_lock is taken to walk process list for sessions

788

* ->siglock is taken to protect ->signal/->sighand

788

* ->siglock is taken to protect ->signal/->sighand

789

*/

789

*/

790

791

void disassociate_ctty(int on_exit)

791

void disassociate_ctty(int on_exit)

792

{

792

{

793

struct tty_struct *tty;

793

struct tty_struct *tty;

794

795

if (!current->signal->leader)

795

if (!current->signal->leader)

796

return;

796

return;

797

798

tty = get_current_tty();

798

tty = get_current_tty();

799

if (tty) {

799

if (tty) {

800

struct pid *tty_pgrp = get_pid(tty->pgrp);

800

struct pid *tty_pgrp = get_pid(tty->pgrp);

801

if (on_exit) {

801

if (on_exit) {

802

if (tty->driver->type != TTY_DRIVER_TYPE_PTY)

802

if (tty->driver->type != TTY_DRIVER_TYPE_PTY)

803

tty_vhangup(tty);

803

tty_vhangup(tty);

804

}

804

}

805

tty_kref_put(tty);

805

tty_kref_put(tty);

806

if (tty_pgrp) {

806

if (tty_pgrp) {

807

kill_pgrp(tty_pgrp, SIGHUP, on_exit);

807

kill_pgrp(tty_pgrp, SIGHUP, on_exit);

808

if (!on_exit)

808

if (!on_exit)

809

kill_pgrp(tty_pgrp, SIGCONT, on_exit);

809

kill_pgrp(tty_pgrp, SIGCONT, on_exit);

810

put_pid(tty_pgrp);

810

put_pid(tty_pgrp);

811

}

811

}

812

} else if (on_exit) {

812

} else if (on_exit) {

813

struct pid *old_pgrp;

813

struct pid *old_pgrp;

814

spin_lock_irq(&current->sighand->siglock);

814

spin_lock_irq(&current->sighand->siglock);

815

old_pgrp = current->signal->tty_old_pgrp;

815

old_pgrp = current->signal->tty_old_pgrp;

816

current->signal->tty_old_pgrp = NULL;

816

current->signal->tty_old_pgrp = NULL;

817

spin_unlock_irq(&current->sighand->siglock);

817

spin_unlock_irq(&current->sighand->siglock);

818

if (old_pgrp) {

818

if (old_pgrp) {

819

kill_pgrp(old_pgrp, SIGHUP, on_exit);

819

kill_pgrp(old_pgrp, SIGHUP, on_exit);

820

kill_pgrp(old_pgrp, SIGCONT, on_exit);

820

kill_pgrp(old_pgrp, SIGCONT, on_exit);

821

put_pid(old_pgrp);

821

put_pid(old_pgrp);

822

}

822

}

823

return;

823

return;

824

}

824

}

825

826

spin_lock_irq(&current->sighand->siglock);

826

spin_lock_irq(&current->sighand->siglock);

827

put_pid(current->signal->tty_old_pgrp);

827

put_pid(current->signal->tty_old_pgrp);

828

current->signal->tty_old_pgrp = NULL;

828

current->signal->tty_old_pgrp = NULL;

829

spin_unlock_irq(&current->sighand->siglock);

829

spin_unlock_irq(&current->sighand->siglock);

830

831

tty = get_current_tty();

831

tty = get_current_tty();

832

if (tty) {

832

if (tty) {

833

unsigned long flags;

833

unsigned long flags;

834

spin_lock_irqsave(&tty->ctrl_lock, flags);

834

spin_lock_irqsave(&tty->ctrl_lock, flags);

835

put_pid(tty->session);

835

put_pid(tty->session);

836

put_pid(tty->pgrp);

836

put_pid(tty->pgrp);

837

tty->session = NULL;

837

tty->session = NULL;

838

tty->pgrp = NULL;

838

tty->pgrp = NULL;

839

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

839

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

840

tty_kref_put(tty);

840

tty_kref_put(tty);

841

} else {

841

} else {

842

#ifdef TTY_DEBUG_HANGUP

842

#ifdef TTY_DEBUG_HANGUP

843

printk(KERN_DEBUG "error attempted to write to tty [0x%p]"

843

printk(KERN_DEBUG "error attempted to write to tty [0x%p]"

844

" = NULL", tty);

844

" = NULL", tty);

845

#endif

845

#endif

846

}

846

}

847

848

/* Now clear signal->tty under the lock */

848

/* Now clear signal->tty under the lock */

849

read_lock(&tasklist_lock);

849

read_lock(&tasklist_lock);

850

session_clear_tty(task_session(current));

850

session_clear_tty(task_session(current));

851

read_unlock(&tasklist_lock);

851

read_unlock(&tasklist_lock);

852

}

852

}

853

854

/**

854

/**

855

*

855

*

856

* no_tty - Ensure the current process does not have a controlling tty

856

* no_tty - Ensure the current process does not have a controlling tty

857

*/

857

*/

858

void no_tty(void)

858

void no_tty(void)

859

{

859

{

860

/* FIXME: Review locking here. The tty_lock never covered any race

860

/* FIXME: Review locking here. The tty_lock never covered any race

861

between a new association and proc_clear_tty but possible we need

861

between a new association and proc_clear_tty but possible we need

862

to protect against this anyway */

862

to protect against this anyway */

863

struct task_struct *tsk = current;

863

struct task_struct *tsk = current;

864

disassociate_ctty(0);

864

disassociate_ctty(0);

865

proc_clear_tty(tsk);

865

proc_clear_tty(tsk);

866

}

866

}

867

868

869

/**

869

/**

870

* stop_tty - propagate flow control

870

* stop_tty - propagate flow control

871

* @tty: tty to stop

871

* @tty: tty to stop

872

*

872

*

873

* Perform flow control to the driver. For PTY/TTY pairs we

873

* Perform flow control to the driver. For PTY/TTY pairs we

874

* must also propagate the TIOCKPKT status. May be called

874

* must also propagate the TIOCKPKT status. May be called

875

* on an already stopped device and will not re-call the driver

875

* on an already stopped device and will not re-call the driver

876

* method.

876

* method.

877

*

877

*

878

* This functionality is used by both the line disciplines for

878

* This functionality is used by both the line disciplines for

879

* halting incoming flow and by the driver. It may therefore be

879

* halting incoming flow and by the driver. It may therefore be

880

* called from any context, may be under the tty atomic_write_lock

880

* called from any context, may be under the tty atomic_write_lock

881

* but not always.

881

* but not always.

882

*

882

*

883

* Locking:

883

* Locking:

884

* Uses the tty control lock internally

884

* Uses the tty control lock internally

885

*/

885

*/

886

887

void stop_tty(struct tty_struct *tty)

887

void stop_tty(struct tty_struct *tty)

888

{

888

{

889

unsigned long flags;

889

unsigned long flags;

890

spin_lock_irqsave(&tty->ctrl_lock, flags);

890

spin_lock_irqsave(&tty->ctrl_lock, flags);

891

if (tty->stopped) {

891

if (tty->stopped) {

892

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

892

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

893

return;

893

return;

894

}

894

}

895

tty->stopped = 1;

895

tty->stopped = 1;

896

if (tty->link && tty->link->packet) {

896

if (tty->link && tty->link->packet) {

897

tty->ctrl_status &= ~TIOCPKT_START;

897

tty->ctrl_status &= ~TIOCPKT_START;

898

tty->ctrl_status |= TIOCPKT_STOP;

898

tty->ctrl_status |= TIOCPKT_STOP;

899

wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);

899

wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);

900

}

900

}

901

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

901

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

902

if (tty->ops->stop)

902

if (tty->ops->stop)

903

(tty->ops->stop)(tty);

903

(tty->ops->stop)(tty);

904

}

904

}

905

906

EXPORT_SYMBOL(stop_tty);

906

EXPORT_SYMBOL(stop_tty);

907

908

/**

908

/**

909

* start_tty - propagate flow control

909

* start_tty - propagate flow control

910

* @tty: tty to start

910

* @tty: tty to start

911

*

911

*

912

* Start a tty that has been stopped if at all possible. Perform

912

* Start a tty that has been stopped if at all possible. Perform

913

* any necessary wakeups and propagate the TIOCPKT status. If this

913

* any necessary wakeups and propagate the TIOCPKT status. If this

914

* is the tty was previous stopped and is being started then the

914

* is the tty was previous stopped and is being started then the

915

* driver start method is invoked and the line discipline woken.

915

* driver start method is invoked and the line discipline woken.

916

*

916

*

917

* Locking:

917

* Locking:

918

* ctrl_lock

918

* ctrl_lock

919

*/

919

*/

920

921

void start_tty(struct tty_struct *tty)

921

void start_tty(struct tty_struct *tty)

922

{

922

{

923

unsigned long flags;

923

unsigned long flags;

924

spin_lock_irqsave(&tty->ctrl_lock, flags);

924

spin_lock_irqsave(&tty->ctrl_lock, flags);

925

if (!tty->stopped || tty->flow_stopped) {

925

if (!tty->stopped || tty->flow_stopped) {

926

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

926

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

927

return;

927

return;

928

}

928

}

929

tty->stopped = 0;

929

tty->stopped = 0;

930

if (tty->link && tty->link->packet) {

930

if (tty->link && tty->link->packet) {

931

tty->ctrl_status &= ~TIOCPKT_STOP;

931

tty->ctrl_status &= ~TIOCPKT_STOP;

932

tty->ctrl_status |= TIOCPKT_START;

932

tty->ctrl_status |= TIOCPKT_START;

933

wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);

933

wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);

934

}

934

}

935

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

935

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

936

if (tty->ops->start)

936

if (tty->ops->start)

937

(tty->ops->start)(tty);

937

(tty->ops->start)(tty);

938

/* If we have a running line discipline it may need kicking */

938

/* If we have a running line discipline it may need kicking */

939

tty_wakeup(tty);

939

tty_wakeup(tty);

940

}

940

}

941

942

EXPORT_SYMBOL(start_tty);

942

EXPORT_SYMBOL(start_tty);

943

944

/**

944

/**

945

* tty_read - read method for tty device files

945

* tty_read - read method for tty device files

946

* @file: pointer to tty file

946

* @file: pointer to tty file

947

* @buf: user buffer

947

* @buf: user buffer

948

* @count: size of user buffer

948

* @count: size of user buffer

949

* @ppos: unused

949

* @ppos: unused

950

*

950

*

951

* Perform the read system call function on this terminal device. Checks

951

* Perform the read system call function on this terminal device. Checks

952

* for hung up devices before calling the line discipline method.

952

* for hung up devices before calling the line discipline method.

953

*

953

*

954

* Locking:

954

* Locking:

955

* Locks the line discipline internally while needed. Multiple

955

* Locks the line discipline internally while needed. Multiple

956

* read calls may be outstanding in parallel.

956

* read calls may be outstanding in parallel.

957

*/

957

*/

958

959

static ssize_t tty_read(struct file *file, char __user *buf, size_t count,

959

static ssize_t tty_read(struct file *file, char __user *buf, size_t count,

960

loff_t *ppos)

960

loff_t *ppos)

961

{

961

{

962

int i;

962

int i;

963

struct inode *inode = file->f_path.dentry->d_inode;

963

struct inode *inode = file->f_path.dentry->d_inode;

964

struct tty_struct *tty = file_tty(file);

964

struct tty_struct *tty = file_tty(file);

965

struct tty_ldisc *ld;

965

struct tty_ldisc *ld;

966

967

if (tty_paranoia_check(tty, inode, "tty_read"))

967

if (tty_paranoia_check(tty, inode, "tty_read"))

968

return -EIO;

968

return -EIO;

969

if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))

969

if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))

970

return -EIO;

970

return -EIO;

971

972

/* We want to wait for the line discipline to sort out in this

972

/* We want to wait for the line discipline to sort out in this

973

situation */

973

situation */

974

ld = tty_ldisc_ref_wait(tty);

974

ld = tty_ldisc_ref_wait(tty);

975

if (ld->ops->read)

975

if (ld->ops->read)

976

i = (ld->ops->read)(tty, file, buf, count);

976

i = (ld->ops->read)(tty, file, buf, count);

977

else

977

else

978

i = -EIO;

978

i = -EIO;

979

tty_ldisc_deref(ld);

979

tty_ldisc_deref(ld);

980

if (i > 0)

980

if (i > 0)

981

inode->i_atime = current_fs_time(inode->i_sb);

981

inode->i_atime = current_fs_time(inode->i_sb);

982

return i;

982

return i;

983

}

983

}

984

985

void tty_write_unlock(struct tty_struct *tty)

985

void tty_write_unlock(struct tty_struct *tty)

986

__releases(&tty->atomic_write_lock)

986

__releases(&tty->atomic_write_lock)

987

{

987

{

988

mutex_unlock(&tty->atomic_write_lock);

988

mutex_unlock(&tty->atomic_write_lock);

989

wake_up_interruptible_poll(&tty->write_wait, POLLOUT);

989

wake_up_interruptible_poll(&tty->write_wait, POLLOUT);

990

}

990

}

991

992

int tty_write_lock(struct tty_struct *tty, int ndelay)

992

int tty_write_lock(struct tty_struct *tty, int ndelay)

993

__acquires(&tty->atomic_write_lock)

993

__acquires(&tty->atomic_write_lock)

994

{

994

{

995

if (!mutex_trylock(&tty->atomic_write_lock)) {

995

if (!mutex_trylock(&tty->atomic_write_lock)) {

996

if (ndelay)

996

if (ndelay)

997

return -EAGAIN;

997

return -EAGAIN;

998

if (mutex_lock_interruptible(&tty->atomic_write_lock))

998

if (mutex_lock_interruptible(&tty->atomic_write_lock))

999

return -ERESTARTSYS;

999

return -ERESTARTSYS;

1000

}

1000

}

1001

return 0;

1001

return 0;

1002

}

1002

}

1003

1004

/*

1004

/*

1005

* Split writes up in sane blocksizes to avoid

1005

* Split writes up in sane blocksizes to avoid

1006

* denial-of-service type attacks

1006

* denial-of-service type attacks

1007

*/

1007

*/

1008

static inline ssize_t do_tty_write(

1008

static inline ssize_t do_tty_write(

1009

ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),

1009

ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),

1010

struct tty_struct *tty,

1010

struct tty_struct *tty,

1011

struct file *file,

1011

struct file *file,

1012

const char __user *buf,

1012

const char __user *buf,

1013

size_t count)

1013

size_t count)

1014

{

1014

{

1015

ssize_t ret, written = 0;

1015

ssize_t ret, written = 0;

1016

unsigned int chunk;

1016

unsigned int chunk;

1017

1018

ret = tty_write_lock(tty, file->f_flags & O_NDELAY);

1018

ret = tty_write_lock(tty, file->f_flags & O_NDELAY);

1019

if (ret < 0)

1019

if (ret < 0)

1020

return ret;

1020

return ret;

1021

1022

/*

1022

/*

1023

* We chunk up writes into a temporary buffer. This

1023

* We chunk up writes into a temporary buffer. This

1024

* simplifies low-level drivers immensely, since they

1024

* simplifies low-level drivers immensely, since they

1025

* don't have locking issues and user mode accesses.

1025

* don't have locking issues and user mode accesses.

1026

*

1026

*

1027

* But if TTY_NO_WRITE_SPLIT is set, we should use a

1027

* But if TTY_NO_WRITE_SPLIT is set, we should use a

1028

* big chunk-size..

1028

* big chunk-size..

1029

*

1029

*

1030

* The default chunk-size is 2kB, because the NTTY

1030

* The default chunk-size is 2kB, because the NTTY

1031

* layer has problems with bigger chunks. It will

1031

* layer has problems with bigger chunks. It will

1032

* claim to be able to handle more characters than

1032

* claim to be able to handle more characters than

1033

* it actually does.

1033

* it actually does.

1034

*

1034

*

1035

* FIXME: This can probably go away now except that 64K chunks

1035

* FIXME: This can probably go away now except that 64K chunks

1036

* are too likely to fail unless switched to vmalloc...

1036

* are too likely to fail unless switched to vmalloc...

1037

*/

1037

*/

1038

chunk = 2048;

1038

chunk = 2048;

1039

if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))

1039

if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))

1040

chunk = 65536;

1040

chunk = 65536;

1041

if (count < chunk)

1041

if (count < chunk)

1042

chunk = count;

1042

chunk = count;

1043

1044

/* write_buf/write_cnt is protected by the atomic_write_lock mutex */

1044

/* write_buf/write_cnt is protected by the atomic_write_lock mutex */

1045

if (tty->write_cnt < chunk) {

1045

if (tty->write_cnt < chunk) {

1046

unsigned char *buf_chunk;

1046

unsigned char *buf_chunk;

1047

1048

if (chunk < 1024)

1048

if (chunk < 1024)

1049

chunk = 1024;

1049

chunk = 1024;

1050

1051

buf_chunk = kmalloc(chunk, GFP_KERNEL);

1051

buf_chunk = kmalloc(chunk, GFP_KERNEL);

1052

if (!buf_chunk) {

1052

if (!buf_chunk) {

1053

ret = -ENOMEM;

1053

ret = -ENOMEM;

1054

goto out;

1054

goto out;

1055

}

1055

}

1056

kfree(tty->write_buf);

1056

kfree(tty->write_buf);

1057

tty->write_cnt = chunk;

1057

tty->write_cnt = chunk;

1058

tty->write_buf = buf_chunk;

1058

tty->write_buf = buf_chunk;

1059

}

1059

}

1060

1061

/* Do the write .. */

1061

/* Do the write .. */

1062

for (;;) {

1062

for (;;) {

1063

size_t size = count;

1063

size_t size = count;

1064

if (size > chunk)

1064

if (size > chunk)

1065

size = chunk;

1065

size = chunk;

1066

ret = -EFAULT;

1066

ret = -EFAULT;

1067

if (copy_from_user(tty->write_buf, buf, size))

1067

if (copy_from_user(tty->write_buf, buf, size))

1068

break;

1068

break;

1069

ret = write(tty, file, tty->write_buf, size);

1069

ret = write(tty, file, tty->write_buf, size);

1070

if (ret <= 0)

1070

if (ret <= 0)

1071

break;

1071

break;

1072

written += ret;

1072

written += ret;

1073

buf += ret;

1073

buf += ret;

1074

count -= ret;

1074

count -= ret;

1075

if (!count)

1075

if (!count)

1076

break;

1076

break;

1077

ret = -ERESTARTSYS;

1077

ret = -ERESTARTSYS;

1078

if (signal_pending(current))

1078

if (signal_pending(current))

1079

break;

1079

break;

1080

cond_resched();

1080

cond_resched();

1081

}

1081

}

1082

if (written) {

1082

if (written) {

1083

struct inode *inode = file->f_path.dentry->d_inode;

1083

struct inode *inode = file->f_path.dentry->d_inode;

1084

inode->i_mtime = current_fs_time(inode->i_sb);

1084

inode->i_mtime = current_fs_time(inode->i_sb);

1085

ret = written;

1085

ret = written;

1086

}

1086

}

1087

out:

1087

out:

1088

tty_write_unlock(tty);

1088

tty_write_unlock(tty);

1089

return ret;

1089

return ret;

1090

}

1090

}

1091

1092

/**

1092

/**

1093

* tty_write_message - write a message to a certain tty, not just the console.

1093

* tty_write_message - write a message to a certain tty, not just the console.

1094

* @tty: the destination tty_struct

1094

* @tty: the destination tty_struct

1095

* @msg: the message to write

1095

* @msg: the message to write

1096

*

1096

*

1097

* This is used for messages that need to be redirected to a specific tty.

1097

* This is used for messages that need to be redirected to a specific tty.

1098

* We don't put it into the syslog queue right now maybe in the future if

1098

* We don't put it into the syslog queue right now maybe in the future if

1099

* really needed.

1099

* really needed.

1100

*

1100

*

1101

* We must still hold the BTM and test the CLOSING flag for the moment.

1101

* We must still hold the BTM and test the CLOSING flag for the moment.

1102

*/

1102

*/

1103

1104

void tty_write_message(struct tty_struct *tty, char *msg)

1104

void tty_write_message(struct tty_struct *tty, char *msg)

1105

{

1105

{

1106

if (tty) {

1106

if (tty) {

1107

mutex_lock(&tty->atomic_write_lock);

1107

mutex_lock(&tty->atomic_write_lock);

1108

tty_lock(tty);

1108

tty_lock(tty);

1109

if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {

1109

if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {

1110

tty_unlock(tty);

1110

tty_unlock(tty);

1111

tty->ops->write(tty, msg, strlen(msg));

1111

tty->ops->write(tty, msg, strlen(msg));

1112

} else

1112

} else

1113

tty_unlock(tty);

1113

tty_unlock(tty);

1114

tty_write_unlock(tty);

1114

tty_write_unlock(tty);

1115

}

1115

}

1116

return;

1116

return;

1117

}

1117

}

1118

1119

1120

/**

1120

/**

1121

* tty_write - write method for tty device file

1121

* tty_write - write method for tty device file

1122

* @file: tty file pointer

1122

* @file: tty file pointer

1123

* @buf: user data to write

1123

* @buf: user data to write

1124

* @count: bytes to write

1124

* @count: bytes to write

1125

* @ppos: unused

1125

* @ppos: unused

1126

*

1126

*

1127

* Write data to a tty device via the line discipline.

1127

* Write data to a tty device via the line discipline.

1128

*

1128

*

1129

* Locking:

1129

* Locking:

1130

* Locks the line discipline as required

1130

* Locks the line discipline as required

1131

* Writes to the tty driver are serialized by the atomic_write_lock

1131

* Writes to the tty driver are serialized by the atomic_write_lock

1132

* and are then processed in chunks to the device. The line discipline

1132

* and are then processed in chunks to the device. The line discipline

1133

* write method will not be invoked in parallel for each device.

1133

* write method will not be invoked in parallel for each device.

1134

*/

1134

*/

1135

1136

static ssize_t tty_write(struct file *file, const char __user *buf,

1136

static ssize_t tty_write(struct file *file, const char __user *buf,

1137

size_t count, loff_t *ppos)

1137

size_t count, loff_t *ppos)

1138

{

1138

{

1139

struct inode *inode = file->f_path.dentry->d_inode;

1139

struct inode *inode = file->f_path.dentry->d_inode;

1140

struct tty_struct *tty = file_tty(file);

1140

struct tty_struct *tty = file_tty(file);

1141

struct tty_ldisc *ld;

1141

struct tty_ldisc *ld;

1142

ssize_t ret;

1142

ssize_t ret;

1143

1144

if (tty_paranoia_check(tty, inode, "tty_write"))

1144

if (tty_paranoia_check(tty, inode, "tty_write"))

1145

return -EIO;

1145

return -EIO;

1146

if (!tty || !tty->ops->write ||

1146

if (!tty || !tty->ops->write ||

1147

(test_bit(TTY_IO_ERROR, &tty->flags)))

1147

(test_bit(TTY_IO_ERROR, &tty->flags)))

1148

return -EIO;

1148

return -EIO;

1149

/* Short term debug to catch buggy drivers */

1149

/* Short term debug to catch buggy drivers */

1150

if (tty->ops->write_room == NULL)

1150

if (tty->ops->write_room == NULL)

1151

printk(KERN_ERR "tty driver %s lacks a write_room method.\n",

1151

printk(KERN_ERR "tty driver %s lacks a write_room method.\n",

1152

tty->driver->name);

1152

tty->driver->name);

1153

ld = tty_ldisc_ref_wait(tty);

1153

ld = tty_ldisc_ref_wait(tty);

1154

if (!ld->ops->write)

1154

if (!ld->ops->write)

1155

ret = -EIO;

1155

ret = -EIO;

1156

else

1156

else

1157

ret = do_tty_write(ld->ops->write, tty, file, buf, count);

1157

ret = do_tty_write(ld->ops->write, tty, file, buf, count);

1158

tty_ldisc_deref(ld);

1158

tty_ldisc_deref(ld);

1159

return ret;

1159

return ret;

1160

}

1160

}

1161

1162

ssize_t redirected_tty_write(struct file *file, const char __user *buf,

1162

ssize_t redirected_tty_write(struct file *file, const char __user *buf,

1163

size_t count, loff_t *ppos)

1163

size_t count, loff_t *ppos)

1164

{

1164

{

1165

struct file *p = NULL;

1165

struct file *p = NULL;

1166

1167

spin_lock(&redirect_lock);

1167

spin_lock(&redirect_lock);

1168

if (redirect)

1168

if (redirect)

1169

p = get_file(redirect);

1169

p = get_file(redirect);

1170

spin_unlock(&redirect_lock);

1170

spin_unlock(&redirect_lock);

1171

1172

if (p) {

1172

if (p) {

1173

ssize_t res;

1173

ssize_t res;

1174

res = vfs_write(p, buf, count, &p->f_pos);

1174

res = vfs_write(p, buf, count, &p->f_pos);

1175

fput(p);

1175

fput(p);

1176

return res;

1176

return res;

1177

}

1177

}

1178

return tty_write(file, buf, count, ppos);

1178

return tty_write(file, buf, count, ppos);

1179

}

1179

}

1180

1181

static char ptychar[] = "pqrstuvwxyzabcde";

1181

static char ptychar[] = "pqrstuvwxyzabcde";

1182

1183

/**

1183

/**

1184

* pty_line_name - generate name for a pty

1184

* pty_line_name - generate name for a pty

1185

* @driver: the tty driver in use

1185

* @driver: the tty driver in use

1186

* @index: the minor number

1186

* @index: the minor number

1187

* @p: output buffer of at least 6 bytes

1187

* @p: output buffer of at least 6 bytes

1188

*

1188

*

1189

* Generate a name from a driver reference and write it to the output

1189

* Generate a name from a driver reference and write it to the output

1190

* buffer.

1190

* buffer.

1191

*

1191

*

1192

* Locking: None

1192

* Locking: None

1193

*/

1193

*/

1194

static void pty_line_name(struct tty_driver *driver, int index, char *p)

1194

static void pty_line_name(struct tty_driver *driver, int index, char *p)

1195

{

1195

{

1196

int i = index + driver->name_base;

1196

int i = index + driver->name_base;

1197

/* ->name is initialized to "ttyp", but "tty" is expected */

1197

/* ->name is initialized to "ttyp", but "tty" is expected */

1198

sprintf(p, "%s%c%x",

1198

sprintf(p, "%s%c%x",

1199

driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,

1199

driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,

1200

ptychar[i >> 4 & 0xf], i & 0xf);

1200

ptychar[i >> 4 & 0xf], i & 0xf);

1201

}

1201

}

1202

1203

/**

1203

/**

1204

* tty_line_name - generate name for a tty

1204

* tty_line_name - generate name for a tty

1205

* @driver: the tty driver in use

1205

* @driver: the tty driver in use

1206

* @index: the minor number

1206

* @index: the minor number

1207

* @p: output buffer of at least 7 bytes

1207

* @p: output buffer of at least 7 bytes

1208

*

1208

*

1209

* Generate a name from a driver reference and write it to the output

1209

* Generate a name from a driver reference and write it to the output

1210

* buffer.

1210

* buffer.

1211

*

1211

*

1212

* Locking: None

1212

* Locking: None

1213

*/

1213

*/

1214

static void tty_line_name(struct tty_driver *driver, int index, char *p)

1214

static void tty_line_name(struct tty_driver *driver, int index, char *p)

1215

{

1215

{

1216

if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)

1216

if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)

1217

strcpy(p, driver->name);

1217

strcpy(p, driver->name);

1218

else

1218

else

1219

sprintf(p, "%s%d", driver->name, index + driver->name_base);

1219

sprintf(p, "%s%d", driver->name, index + driver->name_base);

1220

}

1220

}

1221

1222

/**

1222

/**

1223

* tty_driver_lookup_tty() - find an existing tty, if any

1223

* tty_driver_lookup_tty() - find an existing tty, if any

1224

* @driver: the driver for the tty

1224

* @driver: the driver for the tty

1225

* @idx: the minor number

1225

* @idx: the minor number

1226

*

1226

*

1227

* Return the tty, if found or ERR_PTR() otherwise.

1227

* Return the tty, if found or ERR_PTR() otherwise.

1228

*

1228

*

1229

* Locking: tty_mutex must be held. If tty is found, the mutex must

1229

* Locking: tty_mutex must be held. If tty is found, the mutex must

1230

* be held until the 'fast-open' is also done. Will change once we

1230

* be held until the 'fast-open' is also done. Will change once we

1231

* have refcounting in the driver and per driver locking

1231

* have refcounting in the driver and per driver locking

1232

*/

1232

*/

1233

static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,

1233

static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,

1234

struct inode *inode, int idx)

1234

struct inode *inode, int idx)

1235

{

1235

{

1236

if (driver->ops->lookup)

1236

if (driver->ops->lookup)

1237

return driver->ops->lookup(driver, inode, idx);

1237

return driver->ops->lookup(driver, inode, idx);

1238

1239

return driver->ttys[idx];

1239

return driver->ttys[idx];

1240

}

1240

}

1241

1242

/**

1242

/**

1243

* tty_init_termios - helper for termios setup

1243

* tty_init_termios - helper for termios setup

1244

* @tty: the tty to set up

1244

* @tty: the tty to set up

1245

*

1245

*

1246

* Initialise the termios structures for this tty. Thus runs under

1246

* Initialise the termios structures for this tty. Thus runs under

1247

* the tty_mutex currently so we can be relaxed about ordering.

1247

* the tty_mutex currently so we can be relaxed about ordering.

1248

*/

1248

*/

1249

1250

int tty_init_termios(struct tty_struct *tty)

1250

int tty_init_termios(struct tty_struct *tty)

1251

{

1251

{

1252

struct ktermios *tp;

1252

struct ktermios *tp;

1253

int idx = tty->index;

1253

int idx = tty->index;

1254

1255

if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)

1255

if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)

1256

tty->termios = tty->driver->init_termios;

1256

tty->termios = tty->driver->init_termios;

1257

else {

1257

else {

1258

/* Check for lazy saved data */

1258

/* Check for lazy saved data */

1259

tp = tty->driver->termios[idx];

1259

tp = tty->driver->termios[idx];

1260

if (tp != NULL)

1260

if (tp != NULL)

1261

tty->termios = *tp;

1261

tty->termios = *tp;

1262

else

1262

else

1263

tty->termios = tty->driver->init_termios;

1263

tty->termios = tty->driver->init_termios;

1264

}

1264

}

1265

/* Compatibility until drivers always set this */

1265

/* Compatibility until drivers always set this */

1266

tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);

1266

tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);

1267

tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);

1267

tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);

1268

return 0;

1268

return 0;

1269

}

1269

}

1270

EXPORT_SYMBOL_GPL(tty_init_termios);

1270

EXPORT_SYMBOL_GPL(tty_init_termios);

1271

1272

int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)

1272

int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)

1273

{

1273

{

1274

int ret = tty_init_termios(tty);

1274

int ret = tty_init_termios(tty);

1275

if (ret)

1275

if (ret)

1276

return ret;

1276

return ret;

1277

1278

tty_driver_kref_get(driver);

1278

tty_driver_kref_get(driver);

1279

tty->count++;

1279

tty->count++;

1280

driver->ttys[tty->index] = tty;

1280

driver->ttys[tty->index] = tty;

1281

return 0;

1281

return 0;

1282

}

1282

}

1283

EXPORT_SYMBOL_GPL(tty_standard_install);

1283

EXPORT_SYMBOL_GPL(tty_standard_install);

1284

1285

/**

1285

/**

1286

* tty_driver_install_tty() - install a tty entry in the driver

1286

* tty_driver_install_tty() - install a tty entry in the driver

1287

* @driver: the driver for the tty

1287

* @driver: the driver for the tty

1288

* @tty: the tty

1288

* @tty: the tty

1289

*

1289

*

1290

* Install a tty object into the driver tables. The tty->index field

1290

* Install a tty object into the driver tables. The tty->index field

1291

* will be set by the time this is called. This method is responsible

1291

* will be set by the time this is called. This method is responsible

1292

* for ensuring any need additional structures are allocated and

1292

* for ensuring any need additional structures are allocated and

1293

* configured.

1293

* configured.

1294

*

1294

*

1295

* Locking: tty_mutex for now

1295

* Locking: tty_mutex for now

1296

*/

1296

*/

1297

static int tty_driver_install_tty(struct tty_driver *driver,

1297

static int tty_driver_install_tty(struct tty_driver *driver,

1298

struct tty_struct *tty)

1298

struct tty_struct *tty)

1299

{

1299

{

1300

return driver->ops->install ? driver->ops->install(driver, tty) :

1300

return driver->ops->install ? driver->ops->install(driver, tty) :

1301

tty_standard_install(driver, tty);

1301

tty_standard_install(driver, tty);

1302

}

1302

}

1303

1304

/**

1304

/**

1305

* tty_driver_remove_tty() - remove a tty from the driver tables

1305

* tty_driver_remove_tty() - remove a tty from the driver tables

1306

* @driver: the driver for the tty

1306

* @driver: the driver for the tty

1307

* @idx: the minor number

1307

* @idx: the minor number

1308

*

1308

*

1309

* Remvoe a tty object from the driver tables. The tty->index field

1309

* Remvoe a tty object from the driver tables. The tty->index field

1310

* will be set by the time this is called.

1310

* will be set by the time this is called.

1311

*

1311

*

1312

* Locking: tty_mutex for now

1312

* Locking: tty_mutex for now

1313

*/

1313

*/

1314

void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)

1314

void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)

1315

{

1315

{

1316

if (driver->ops->remove)

1316

if (driver->ops->remove)

1317

driver->ops->remove(driver, tty);

1317

driver->ops->remove(driver, tty);

1318

else

1318

else

1319

driver->ttys[tty->index] = NULL;

1319

driver->ttys[tty->index] = NULL;

1320

}

1320

}

1321

1322

/*

1322

/*

1323

* tty_reopen() - fast re-open of an open tty

1323

* tty_reopen() - fast re-open of an open tty

1324

* @tty - the tty to open

1324

* @tty - the tty to open

1325

*

1325

*

1326

* Return 0 on success, -errno on error.

1326

* Return 0 on success, -errno on error.

1327

*

1327

*

1328

* Locking: tty_mutex must be held from the time the tty was found

1328

* Locking: tty_mutex must be held from the time the tty was found

1329

* till this open completes.

1329

* till this open completes.

1330

*/

1330

*/

1331

static int tty_reopen(struct tty_struct *tty)

1331

static int tty_reopen(struct tty_struct *tty)

1332

{

1332

{

1333

struct tty_driver *driver = tty->driver;

1333

struct tty_driver *driver = tty->driver;

1334

1335

if (test_bit(TTY_CLOSING, &tty->flags) ||

1335

if (test_bit(TTY_CLOSING, &tty->flags) ||

1336

test_bit(TTY_HUPPING, &tty->flags) ||

1336

test_bit(TTY_HUPPING, &tty->flags) ||

1337

test_bit(TTY_LDISC_CHANGING, &tty->flags))

1337

test_bit(TTY_LDISC_CHANGING, &tty->flags))

1338

return -EIO;

1338

return -EIO;

1339

1340

if (driver->type == TTY_DRIVER_TYPE_PTY &&

1340

if (driver->type == TTY_DRIVER_TYPE_PTY &&

1341

driver->subtype == PTY_TYPE_MASTER) {

1341

driver->subtype == PTY_TYPE_MASTER) {

1342

/*

1342

/*

1343

* special case for PTY masters: only one open permitted,

1343

* special case for PTY masters: only one open permitted,

1344

* and the slave side open count is incremented as well.

1344

* and the slave side open count is incremented as well.

1345

*/

1345

*/

1346

if (tty->count)

1346

if (tty->count)

1347

return -EIO;

1347

return -EIO;

1348

1349

tty->link->count++;

1349

tty->link->count++;

1350

}

1350

}

1351

tty->count++;

1351

tty->count++;

1352

1353

mutex_lock(&tty->ldisc_mutex);

1353

mutex_lock(&tty->ldisc_mutex);

1354

WARN_ON(!test_bit(TTY_LDISC, &tty->flags));

1354

WARN_ON(!test_bit(TTY_LDISC, &tty->flags));

1355

mutex_unlock(&tty->ldisc_mutex);

1355

mutex_unlock(&tty->ldisc_mutex);

1356

1357

return 0;

1357

return 0;

1358

}

1358

}

1359

1360

/**

1360

/**

1361

* tty_init_dev - initialise a tty device

1361

* tty_init_dev - initialise a tty device

1362

* @driver: tty driver we are opening a device on

1362

* @driver: tty driver we are opening a device on

1363

* @idx: device index

1363

* @idx: device index

1364

* @ret_tty: returned tty structure

1364

* @ret_tty: returned tty structure

1365

*

1365

*

1366

* Prepare a tty device. This may not be a "new" clean device but

1366

* Prepare a tty device. This may not be a "new" clean device but

1367

* could also be an active device. The pty drivers require special

1367

* could also be an active device. The pty drivers require special

1368

* handling because of this.

1368

* handling because of this.

1369

*

1369

*

1370

* Locking:

1370

* Locking:

1371

* The function is called under the tty_mutex, which

1371

* The function is called under the tty_mutex, which

1372

* protects us from the tty struct or driver itself going away.

1372

* protects us from the tty struct or driver itself going away.

1373

*

1373

*

1374

* On exit the tty device has the line discipline attached and

1374

* On exit the tty device has the line discipline attached and

1375

* a reference count of 1. If a pair was created for pty/tty use

1375

* a reference count of 1. If a pair was created for pty/tty use

1376

* and the other was a pty master then it too has a reference count of 1.

1376

* and the other was a pty master then it too has a reference count of 1.

1377

*

1377

*

1378

* WSH 06/09/97: Rewritten to remove races and properly clean up after a

1378

* WSH 06/09/97: Rewritten to remove races and properly clean up after a

1379

* failed open. The new code protects the open with a mutex, so it's

1379

* failed open. The new code protects the open with a mutex, so it's

1380

* really quite straightforward. The mutex locking can probably be

1380

* really quite straightforward. The mutex locking can probably be

1381

* relaxed for the (most common) case of reopening a tty.

1381

* relaxed for the (most common) case of reopening a tty.

1382

*/

1382

*/

1383

1384

struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)

1384

struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)

1385

{

1385

{

1386

struct tty_struct *tty;

1386

struct tty_struct *tty;

1387

int retval;

1387

int retval;

1388

1389

/*

1389

/*

1390

* First time open is complex, especially for PTY devices.

1390

* First time open is complex, especially for PTY devices.

1391

* This code guarantees that either everything succeeds and the

1391

* This code guarantees that either everything succeeds and the

1392

* TTY is ready for operation, or else the table slots are vacated

1392

* TTY is ready for operation, or else the table slots are vacated

1393

* and the allocated memory released. (Except that the termios

1393

* and the allocated memory released. (Except that the termios

1394

* and locked termios may be retained.)

1394

* and locked termios may be retained.)

1395

*/

1395

*/

1396

1397

if (!try_module_get(driver->owner))

1397

if (!try_module_get(driver->owner))

1398

return ERR_PTR(-ENODEV);

1398

return ERR_PTR(-ENODEV);

1399

1400

tty = alloc_tty_struct();

1400

tty = alloc_tty_struct();

1401

if (!tty) {

1401

if (!tty) {

1402

retval = -ENOMEM;

1402

retval = -ENOMEM;

1403

goto err_module_put;

1403

goto err_module_put;

1404

}

1404

}

1405

initialize_tty_struct(tty, driver, idx);

1405

initialize_tty_struct(tty, driver, idx);

1406

1407

tty_lock(tty);

1407

tty_lock(tty);

1408

retval = tty_driver_install_tty(driver, tty);

1408

retval = tty_driver_install_tty(driver, tty);

1409

if (retval < 0)

1409

if (retval < 0)

1410

goto err_deinit_tty;

1410

goto err_deinit_tty;

1411

1412

if (!tty->port)

1412

if (!tty->port)

1413

tty->port = driver->ports[idx];

1413

tty->port = driver->ports[idx];

1414

1415

WARN_RATELIMIT(!tty->port,

1415

WARN_RATELIMIT(!tty->port,

1416

"%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",

1416

"%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",

1417

__func__, tty->driver->name);

1417

__func__, tty->driver->name);

1418

1419

tty->port->itty = tty;

1419

tty->port->itty = tty;

1420

1421

/*

1421

/*

1422

* Structures all installed ... call the ldisc open routines.

1422

* Structures all installed ... call the ldisc open routines.

1423

* If we fail here just call release_tty to clean up. No need

1423

* If we fail here just call release_tty to clean up. No need

1424

* to decrement the use counts, as release_tty doesn't care.

1424

* to decrement the use counts, as release_tty doesn't care.

1425

*/

1425

*/

1426

retval = tty_ldisc_setup(tty, tty->link);

1426

retval = tty_ldisc_setup(tty, tty->link);

1427

if (retval)

1427

if (retval)

1428

goto err_release_tty;

1428

goto err_release_tty;

1429

/* Return the tty locked so that it cannot vanish under the caller */

1429

/* Return the tty locked so that it cannot vanish under the caller */

1430

return tty;

1430

return tty;

1431

1432

err_deinit_tty:

1432

err_deinit_tty:

1433

tty_unlock(tty);

1433

tty_unlock(tty);

1434

deinitialize_tty_struct(tty);

1434

deinitialize_tty_struct(tty);

1435

free_tty_struct(tty);

1435

free_tty_struct(tty);

1436

err_module_put:

1436

err_module_put:

1437

module_put(driver->owner);

1437

module_put(driver->owner);

1438

return ERR_PTR(retval);

1438

return ERR_PTR(retval);

1439

1440

/* call the tty release_tty routine to clean out this slot */

1440

/* call the tty release_tty routine to clean out this slot */

1441

err_release_tty:

1441

err_release_tty:

1442

tty_unlock(tty);

1442

tty_unlock(tty);

1443

printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "

1443

printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "

1444

"clearing slot %d\n", idx);

1444

"clearing slot %d\n", idx);

1445

release_tty(tty, idx);

1445

release_tty(tty, idx);

1446

return ERR_PTR(retval);

1446

return ERR_PTR(retval);

1447

}

1447

}

1448

1449

void tty_free_termios(struct tty_struct *tty)

1449

void tty_free_termios(struct tty_struct *tty)

1450

{

1450

{

1451

struct ktermios *tp;

1451

struct ktermios *tp;

1452

int idx = tty->index;

1452

int idx = tty->index;

1453

1454

/* If the port is going to reset then it has no termios to save */

1454

/* If the port is going to reset then it has no termios to save */

1455

if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)

1455

if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)

1456

return;

1456

return;

1457

1458

/* Stash the termios data */

1458

/* Stash the termios data */

1459

tp = tty->driver->termios[idx];

1459

tp = tty->driver->termios[idx];

1460

if (tp == NULL) {

1460

if (tp == NULL) {

1461

tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);

1461

tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);

1462

if (tp == NULL) {

1462

if (tp == NULL) {

1463

pr_warn("tty: no memory to save termios state.\n");

1463

pr_warn("tty: no memory to save termios state.\n");

1464

return;

1464

return;

1465

}

1465

}

1466

tty->driver->termios[idx] = tp;

1466

tty->driver->termios[idx] = tp;

1467

}

1467

}

1468

*tp = tty->termios;

1468

*tp = tty->termios;

1469

}

1469

}

1470

EXPORT_SYMBOL(tty_free_termios);

1470

EXPORT_SYMBOL(tty_free_termios);

1471

1472

1473

/**

1473

/**

1474

* release_one_tty - release tty structure memory

1474

* release_one_tty - release tty structure memory

1475

* @kref: kref of tty we are obliterating

1475

* @kref: kref of tty we are obliterating

1476

*

1476

*

1477

* Releases memory associated with a tty structure, and clears out the

1477

* Releases memory associated with a tty structure, and clears out the

1478

* driver table slots. This function is called when a device is no longer

1478

* driver table slots. This function is called when a device is no longer

1479

* in use. It also gets called when setup of a device fails.

1479

* in use. It also gets called when setup of a device fails.

1480

*

1480

*

1481

* Locking:

1481

* Locking:

1482

* takes the file list lock internally when working on the list

1482

* takes the file list lock internally when working on the list

1483

* of ttys that the driver keeps.

1483

* of ttys that the driver keeps.

1484

*

1484

*

1485

* This method gets called from a work queue so that the driver private

1485

* This method gets called from a work queue so that the driver private

1486

* cleanup ops can sleep (needed for USB at least)

1486

* cleanup ops can sleep (needed for USB at least)

1487

*/

1487

*/

1488

static void release_one_tty(struct work_struct *work)

1488

static void release_one_tty(struct work_struct *work)

1489

{

1489

{

1490

struct tty_struct *tty =

1490

struct tty_struct *tty =

1491

container_of(work, struct tty_struct, hangup_work);

1491

container_of(work, struct tty_struct, hangup_work);

1492

struct tty_driver *driver = tty->driver;

1492

struct tty_driver *driver = tty->driver;

1493

1494

if (tty->ops->cleanup)

1494

if (tty->ops->cleanup)

1495

tty->ops->cleanup(tty);

1495

tty->ops->cleanup(tty);

1496

1497

tty->magic = 0;

1497

tty->magic = 0;

1498

tty_driver_kref_put(driver);

1498

tty_driver_kref_put(driver);

1499

module_put(driver->owner);

1499

module_put(driver->owner);

1500

1501

spin_lock(&tty_files_lock);

1501

spin_lock(&tty_files_lock);

1502

list_del_init(&tty->tty_files);

1502

list_del_init(&tty->tty_files);

1503

spin_unlock(&tty_files_lock);

1503

spin_unlock(&tty_files_lock);

1504

1505

put_pid(tty->pgrp);

1505

put_pid(tty->pgrp);

1506

put_pid(tty->session);

1506

put_pid(tty->session);

1507

free_tty_struct(tty);

1507

free_tty_struct(tty);

1508

}

1508

}

1509

1510

static void queue_release_one_tty(struct kref *kref)

1510

static void queue_release_one_tty(struct kref *kref)

1511

{

1511

{

1512

struct tty_struct *tty = container_of(kref, struct tty_struct, kref);

1512

struct tty_struct *tty = container_of(kref, struct tty_struct, kref);

1513

1514

/* The hangup queue is now free so we can reuse it rather than

1514

/* The hangup queue is now free so we can reuse it rather than

1515

waste a chunk of memory for each port */

1515

waste a chunk of memory for each port */

1516

INIT_WORK(&tty->hangup_work, release_one_tty);

1516

INIT_WORK(&tty->hangup_work, release_one_tty);

1517

schedule_work(&tty->hangup_work);

1517

schedule_work(&tty->hangup_work);

1518

}

1518

}

1519

1520

/**

1520

/**

1521

* tty_kref_put - release a tty kref

1521

* tty_kref_put - release a tty kref

1522

* @tty: tty device

1522

* @tty: tty device

1523

*

1523

*

1524

* Release a reference to a tty device and if need be let the kref

1524

* Release a reference to a tty device and if need be let the kref

1525

* layer destruct the object for us

1525

* layer destruct the object for us

1526

*/

1526

*/

1527

1528

void tty_kref_put(struct tty_struct *tty)

1528

void tty_kref_put(struct tty_struct *tty)

1529

{

1529

{

1530

if (tty)

1530

if (tty)

1531

kref_put(&tty->kref, queue_release_one_tty);

1531

kref_put(&tty->kref, queue_release_one_tty);

1532

}

1532

}

1533

EXPORT_SYMBOL(tty_kref_put);

1533

EXPORT_SYMBOL(tty_kref_put);

1534

1535

/**

1535

/**

1536

* release_tty - release tty structure memory

1536

* release_tty - release tty structure memory

1537

*

1537

*

1538

* Release both @tty and a possible linked partner (think pty pair),

1538

* Release both @tty and a possible linked partner (think pty pair),

1539

* and decrement the refcount of the backing module.

1539

* and decrement the refcount of the backing module.

1540

*

1540

*

1541

* Locking:

1541

* Locking:

1542

* tty_mutex

1542

* tty_mutex

1543

* takes the file list lock internally when working on the list

1543

* takes the file list lock internally when working on the list

1544

* of ttys that the driver keeps.

1544

* of ttys that the driver keeps.

1545

*

1545

*

1546

*/

1546

*/

1547

static void release_tty(struct tty_struct *tty, int idx)

1547

static void release_tty(struct tty_struct *tty, int idx)

1548

{

1548

{

1549

/* This should always be true but check for the moment */

1549

/* This should always be true but check for the moment */

1550

WARN_ON(tty->index != idx);

1550

WARN_ON(tty->index != idx);

1551

WARN_ON(!mutex_is_locked(&tty_mutex));

1551

WARN_ON(!mutex_is_locked(&tty_mutex));

1552

if (tty->ops->shutdown)

1552

if (tty->ops->shutdown)

1553

tty->ops->shutdown(tty);

1553

tty->ops->shutdown(tty);

1554

tty_free_termios(tty);

1554

tty_free_termios(tty);

1555

tty_driver_remove_tty(tty->driver, tty);

1555

tty_driver_remove_tty(tty->driver, tty);

1556

tty->port->itty = NULL;

1556

tty->port->itty = NULL;

1557

1558

if (tty->link)

1558

if (tty->link)

1559

tty_kref_put(tty->link);

1559

tty_kref_put(tty->link);

1560

tty_kref_put(tty);

1560

tty_kref_put(tty);

1561

}

1561

}

1562

1563

/**

1563

/**

1564

* tty_release_checks - check a tty before real release

1564

* tty_release_checks - check a tty before real release

1565

* @tty: tty to check

1565

* @tty: tty to check

1566

* @o_tty: link of @tty (if any)

1566

* @o_tty: link of @tty (if any)

1567

* @idx: index of the tty

1567

* @idx: index of the tty

1568

*

1568

*

1569

* Performs some paranoid checking before true release of the @tty.

1569

* Performs some paranoid checking before true release of the @tty.

1570

* This is a no-op unless TTY_PARANOIA_CHECK is defined.

1570

* This is a no-op unless TTY_PARANOIA_CHECK is defined.

1571

*/

1571

*/

1572

static int tty_release_checks(struct tty_struct *tty, struct tty_struct *o_tty,

1572

static int tty_release_checks(struct tty_struct *tty, struct tty_struct *o_tty,

1573

int idx)

1573

int idx)

1574

{

1574

{

1575

#ifdef TTY_PARANOIA_CHECK

1575

#ifdef TTY_PARANOIA_CHECK

1576

if (idx < 0 || idx >= tty->driver->num) {

1576

if (idx < 0 || idx >= tty->driver->num) {

1577

printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",

1577

printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",

1578

__func__, tty->name);

1578

__func__, tty->name);

1579

return -1;

1579

return -1;

1580

}

1580

}

1581

1582

/* not much to check for devpts */

1582

/* not much to check for devpts */

1583

if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)

1583

if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)

1584

return 0;

1584

return 0;

1585

1586

if (tty != tty->driver->ttys[idx]) {

1586

if (tty != tty->driver->ttys[idx]) {

1587

printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",

1587

printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",

1588

__func__, idx, tty->name);

1588

__func__, idx, tty->name);

1589

return -1;

1589

return -1;

1590

}

1590

}

1591

if (tty->driver->other) {

1591

if (tty->driver->other) {

1592

if (o_tty != tty->driver->other->ttys[idx]) {

1592

if (o_tty != tty->driver->other->ttys[idx]) {

1593

printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",

1593

printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",

1594

__func__, idx, tty->name);

1594

__func__, idx, tty->name);

1595

return -1;

1595

return -1;

1596

}

1596

}

1597

if (o_tty->link != tty) {

1597

if (o_tty->link != tty) {

1598

printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);

1598

printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);

1599

return -1;

1599

return -1;

1600

}

1600

}

1601

}

1601

}

1602

#endif

1602

#endif

1603

return 0;

1603

return 0;

1604

}

1604

}

1605

1606

/**

1606

/**

1607

* tty_release - vfs callback for close

1607

* tty_release - vfs callback for close

1608

* @inode: inode of tty

1608

* @inode: inode of tty

1609

* @filp: file pointer for handle to tty

1609

* @filp: file pointer for handle to tty

1610

*

1610

*

1611

* Called the last time each file handle is closed that references

1611

* Called the last time each file handle is closed that references

1612

* this tty. There may however be several such references.

1612

* this tty. There may however be several such references.

1613

*

1613

*

1614

* Locking:

1614

* Locking:

1615

* Takes bkl. See tty_release_dev

1615

* Takes bkl. See tty_release_dev

1616

*

1616

*

1617

* Even releasing the tty structures is a tricky business.. We have

1617

* Even releasing the tty structures is a tricky business.. We have

1618

* to be very careful that the structures are all released at the

1618

* to be very careful that the structures are all released at the

1619

* same time, as interrupts might otherwise get the wrong pointers.

1619

* same time, as interrupts might otherwise get the wrong pointers.

1620

*

1620

*

1621

* WSH 09/09/97: rewritten to avoid some nasty race conditions that could

1621

* WSH 09/09/97: rewritten to avoid some nasty race conditions that could

1622

* lead to double frees or releasing memory still in use.

1622

* lead to double frees or releasing memory still in use.

1623

*/

1623

*/

1624

1625

int tty_release(struct inode *inode, struct file *filp)

1625

int tty_release(struct inode *inode, struct file *filp)

1626

{

1626

{

1627

struct tty_struct *tty = file_tty(filp);

1627

struct tty_struct *tty = file_tty(filp);

1628

struct tty_struct *o_tty;

1628

struct tty_struct *o_tty;

1629

int pty_master, tty_closing, o_tty_closing, do_sleep;

1629

int pty_master, tty_closing, o_tty_closing, do_sleep;

1630

int idx;

1630

int idx;

1631

char buf[64];

1631

char buf[64];

1632

1633

if (tty_paranoia_check(tty, inode, __func__))

1633

if (tty_paranoia_check(tty, inode, __func__))

1634

return 0;

1634

return 0;

1635

1636

tty_lock(tty);

1636

tty_lock(tty);

1637

check_tty_count(tty, __func__);

1637

check_tty_count(tty, __func__);

1638

1639

__tty_fasync(-1, filp, 0);

1639

__tty_fasync(-1, filp, 0);

1640

1641

idx = tty->index;

1641

idx = tty->index;

1642

pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&

1642

pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&

1643

tty->driver->subtype == PTY_TYPE_MASTER);

1643

tty->driver->subtype == PTY_TYPE_MASTER);

1644

/* Review: parallel close */

1644

/* Review: parallel close */

1645

o_tty = tty->link;

1645

o_tty = tty->link;

1646

1647

if (tty_release_checks(tty, o_tty, idx)) {

1647

if (tty_release_checks(tty, o_tty, idx)) {

1648

tty_unlock(tty);

1648

tty_unlock(tty);

1649

return 0;

1649

return 0;

1650

}

1650

}

1651

1652

#ifdef TTY_DEBUG_HANGUP

1652

#ifdef TTY_DEBUG_HANGUP

1653

printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,

1653

printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,

1654

tty_name(tty, buf), tty->count);

1654

tty_name(tty, buf), tty->count);

1655

#endif

1655

#endif

1656

1657

if (tty->ops->close)

1657

if (tty->ops->close)

1658

tty->ops->close(tty, filp);

1658

tty->ops->close(tty, filp);

1659

1660

tty_unlock(tty);

1660

tty_unlock(tty);

1661

/*

1661

/*

1662

* Sanity check: if tty->count is going to zero, there shouldn't be

1662

* Sanity check: if tty->count is going to zero, there shouldn't be

1663

* any waiters on tty->read_wait or tty->write_wait. We test the

1663

* any waiters on tty->read_wait or tty->write_wait. We test the

1664

* wait queues and kick everyone out _before_ actually starting to

1664

* wait queues and kick everyone out _before_ actually starting to

1665

* close. This ensures that we won't block while releasing the tty

1665

* close. This ensures that we won't block while releasing the tty

1666

* structure.

1666

* structure.

1667

*

1667

*

1668

* The test for the o_tty closing is necessary, since the master and

1668

* The test for the o_tty closing is necessary, since the master and

1669

* slave sides may close in any order. If the slave side closes out

1669

* slave sides may close in any order. If the slave side closes out

1670

* first, its count will be one, since the master side holds an open.

1670

* first, its count will be one, since the master side holds an open.

1671

* Thus this test wouldn't be triggered at the time the slave closes,

1671

* Thus this test wouldn't be triggered at the time the slave closes,

1672

* so we do it now.

1672

* so we do it now.

1673

*

1673

*

1674

* Note that it's possible for the tty to be opened again while we're

1674

* Note that it's possible for the tty to be opened again while we're

1675

* flushing out waiters. By recalculating the closing flags before

1675

* flushing out waiters. By recalculating the closing flags before

1676

* each iteration we avoid any problems.

1676

* each iteration we avoid any problems.

1677

*/

1677

*/

1678

while (1) {

1678

while (1) {

1679

/* Guard against races with tty->count changes elsewhere and

1679

/* Guard against races with tty->count changes elsewhere and

1680

opens on /dev/tty */

1680

opens on /dev/tty */

1681

1682

mutex_lock(&tty_mutex);

1682

mutex_lock(&tty_mutex);

1683

tty_lock_pair(tty, o_tty);

1683

tty_lock_pair(tty, o_tty);

1684

tty_closing = tty->count <= 1;

1684

tty_closing = tty->count <= 1;

1685

o_tty_closing = o_tty &&

1685

o_tty_closing = o_tty &&

1686

(o_tty->count <= (pty_master ? 1 : 0));

1686

(o_tty->count <= (pty_master ? 1 : 0));

1687

do_sleep = 0;

1687

do_sleep = 0;

1688

1689

if (tty_closing) {

1689

if (tty_closing) {

1690

if (waitqueue_active(&tty->read_wait)) {

1690

if (waitqueue_active(&tty->read_wait)) {

1691

wake_up_poll(&tty->read_wait, POLLIN);

1691

wake_up_poll(&tty->read_wait, POLLIN);

1692

do_sleep++;

1692

do_sleep++;

1693

}

1693

}

1694

if (waitqueue_active(&tty->write_wait)) {

1694

if (waitqueue_active(&tty->write_wait)) {

1695

wake_up_poll(&tty->write_wait, POLLOUT);

1695

wake_up_poll(&tty->write_wait, POLLOUT);

1696

do_sleep++;

1696

do_sleep++;

1697

}

1697

}

1698

}

1698

}

1699

if (o_tty_closing) {

1699

if (o_tty_closing) {

1700

if (waitqueue_active(&o_tty->read_wait)) {

1700

if (waitqueue_active(&o_tty->read_wait)) {

1701

wake_up_poll(&o_tty->read_wait, POLLIN);

1701

wake_up_poll(&o_tty->read_wait, POLLIN);

1702

do_sleep++;

1702

do_sleep++;

1703

}

1703

}

1704

if (waitqueue_active(&o_tty->write_wait)) {

1704

if (waitqueue_active(&o_tty->write_wait)) {

1705

wake_up_poll(&o_tty->write_wait, POLLOUT);

1705

wake_up_poll(&o_tty->write_wait, POLLOUT);

1706

do_sleep++;

1706

do_sleep++;

1707

}

1707

}

1708

}

1708

}

1709

if (!do_sleep)

1709

if (!do_sleep)

1710

break;

1710

break;

1711

1712

printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",

1712

printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",

1713

__func__, tty_name(tty, buf));

1713

__func__, tty_name(tty, buf));

1714

tty_unlock_pair(tty, o_tty);

1714

tty_unlock_pair(tty, o_tty);

1715

mutex_unlock(&tty_mutex);

1715

mutex_unlock(&tty_mutex);

1716

schedule();

1716

schedule();

1717

}

1717

}

1718

1719

/*

1719

/*

1720

* The closing flags are now consistent with the open counts on

1720

* The closing flags are now consistent with the open counts on

1721

* both sides, and we've completed the last operation that could

1721

* both sides, and we've completed the last operation that could

1722

* block, so it's safe to proceed with closing.

1722

* block, so it's safe to proceed with closing.

1723

*

1723

*

1724

* We must *not* drop the tty_mutex until we ensure that a further

1724

* We must *not* drop the tty_mutex until we ensure that a further

1725

* entry into tty_open can not pick up this tty.

1725

* entry into tty_open can not pick up this tty.

1726

*/

1726

*/

1727

if (pty_master) {

1727

if (pty_master) {

1728

if (--o_tty->count < 0) {

1728

if (--o_tty->count < 0) {

1729

printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",

1729

printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",

1730

__func__, o_tty->count, tty_name(o_tty, buf));

1730

__func__, o_tty->count, tty_name(o_tty, buf));

1731

o_tty->count = 0;

1731

o_tty->count = 0;

1732

}

1732

}

1733

}

1733

}

1734

if (--tty->count < 0) {

1734

if (--tty->count < 0) {

1735

printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",

1735

printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",

1736

__func__, tty->count, tty_name(tty, buf));

1736

__func__, tty->count, tty_name(tty, buf));

1737

tty->count = 0;

1737

tty->count = 0;

1738

}

1738

}

1739

1740

/*

1740

/*

1741

* We've decremented tty->count, so we need to remove this file

1741

* We've decremented tty->count, so we need to remove this file

1742

* descriptor off the tty->tty_files list; this serves two

1742

* descriptor off the tty->tty_files list; this serves two

1743

* purposes:

1743

* purposes:

1744

* - check_tty_count sees the correct number of file descriptors

1744

* - check_tty_count sees the correct number of file descriptors

1745

* associated with this tty.

1745

* associated with this tty.

1746

* - do_tty_hangup no longer sees this file descriptor as

1746

* - do_tty_hangup no longer sees this file descriptor as

1747

* something that needs to be handled for hangups.

1747

* something that needs to be handled for hangups.

1748

*/

1748

*/

1749

tty_del_file(filp);

1749

tty_del_file(filp);

1750

1751

/*

1751

/*

1752

* Perform some housekeeping before deciding whether to return.

1752

* Perform some housekeeping before deciding whether to return.

1753

*

1753

*

1754

* Set the TTY_CLOSING flag if this was the last open. In the

1754

* Set the TTY_CLOSING flag if this was the last open. In the

1755

* case of a pty we may have to wait around for the other side

1755

* case of a pty we may have to wait around for the other side

1756

* to close, and TTY_CLOSING makes sure we can't be reopened.

1756

* to close, and TTY_CLOSING makes sure we can't be reopened.

1757

*/

1757

*/

1758

if (tty_closing)

1758

if (tty_closing)

1759

set_bit(TTY_CLOSING, &tty->flags);

1759

set_bit(TTY_CLOSING, &tty->flags);

1760

if (o_tty_closing)

1760

if (o_tty_closing)

1761

set_bit(TTY_CLOSING, &o_tty->flags);

1761

set_bit(TTY_CLOSING, &o_tty->flags);

1762

1763

/*

1763

/*

1764

* If _either_ side is closing, make sure there aren't any

1764

* If _either_ side is closing, make sure there aren't any

1765

* processes that still think tty or o_tty is their controlling

1765

* processes that still think tty or o_tty is their controlling

1766

* tty.

1766

* tty.

1767

*/

1767

*/

1768

if (tty_closing || o_tty_closing) {

1768

if (tty_closing || o_tty_closing) {

1769

read_lock(&tasklist_lock);

1769

read_lock(&tasklist_lock);

1770

session_clear_tty(tty->session);

1770

session_clear_tty(tty->session);

1771

if (o_tty)

1771

if (o_tty)

1772

session_clear_tty(o_tty->session);

1772

session_clear_tty(o_tty->session);

1773

read_unlock(&tasklist_lock);

1773

read_unlock(&tasklist_lock);

1774

}

1774

}

1775

1776

mutex_unlock(&tty_mutex);

1776

mutex_unlock(&tty_mutex);

1777

tty_unlock_pair(tty, o_tty);

1777

tty_unlock_pair(tty, o_tty);

1778

/* At this point the TTY_CLOSING flag should ensure a dead tty

1778

/* At this point the TTY_CLOSING flag should ensure a dead tty

1779

cannot be re-opened by a racing opener */

1779

cannot be re-opened by a racing opener */

1780

1781

/* check whether both sides are closing ... */

1781

/* check whether both sides are closing ... */

1782

if (!tty_closing || (o_tty && !o_tty_closing))

1782

if (!tty_closing || (o_tty && !o_tty_closing))

1783

return 0;

1783

return 0;

1784

1785

#ifdef TTY_DEBUG_HANGUP

1785

#ifdef TTY_DEBUG_HANGUP

1786

printk(KERN_DEBUG "%s: freeing tty structure...\n", __func__);

1786

printk(KERN_DEBUG "%s: freeing tty structure...\n", __func__);

1787

#endif

1787

#endif

1788

/*

1788

/*

1789

* Ask the line discipline code to release its structures

1789

* Ask the line discipline code to release its structures

1790

*/

1790

*/

1791

tty_ldisc_release(tty, o_tty);

1791

tty_ldisc_release(tty, o_tty);

1792

/*

1792

/*

1793

* The release_tty function takes care of the details of clearing

1793

* The release_tty function takes care of the details of clearing

1794

* the slots and preserving the termios structure. The tty_unlock_pair

1794

* the slots and preserving the termios structure. The tty_unlock_pair

1795

* should be safe as we keep a kref while the tty is locked (so the

1795

* should be safe as we keep a kref while the tty is locked (so the

1796

* unlock never unlocks a freed tty).

1796

* unlock never unlocks a freed tty).

1797

*/

1797

*/

1798

mutex_lock(&tty_mutex);

1798

mutex_lock(&tty_mutex);

1799

release_tty(tty, idx);

1799

release_tty(tty, idx);

1800

mutex_unlock(&tty_mutex);

1800

mutex_unlock(&tty_mutex);

1801

1802

return 0;

1802

return 0;

1803

}

1803

}

1804

1805

/**

1805

/**

1806

* tty_open_current_tty - get tty of current task for open

1806

* tty_open_current_tty - get tty of current task for open

1807

* @device: device number

1807

* @device: device number

1808

* @filp: file pointer to tty

1808

* @filp: file pointer to tty

1809

* @return: tty of the current task iff @device is /dev/tty

1809

* @return: tty of the current task iff @device is /dev/tty

1810

*

1810

*

1811

* We cannot return driver and index like for the other nodes because

1811

* We cannot return driver and index like for the other nodes because

1812

* devpts will not work then. It expects inodes to be from devpts FS.

1812

* devpts will not work then. It expects inodes to be from devpts FS.

1813

*

1813

*

1814

* We need to move to returning a refcounted object from all the lookup

1814

* We need to move to returning a refcounted object from all the lookup

1815

* paths including this one.

1815

* paths including this one.

1816

*/

1816

*/

1817

static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)

1817

static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)

1818

{

1818

{

1819

struct tty_struct *tty;

1819

struct tty_struct *tty;

1820

1821

if (device != MKDEV(TTYAUX_MAJOR, 0))

1821

if (device != MKDEV(TTYAUX_MAJOR, 0))

1822

return NULL;

1822

return NULL;

1823

1824

tty = get_current_tty();

1824

tty = get_current_tty();

1825

if (!tty)

1825

if (!tty)

1826

return ERR_PTR(-ENXIO);

1826

return ERR_PTR(-ENXIO);

1827

1828

filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */

1828

filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */

1829

/* noctty = 1; */

1829

/* noctty = 1; */

1830

tty_kref_put(tty);

1830

tty_kref_put(tty);

1831

/* FIXME: we put a reference and return a TTY! */

1831

/* FIXME: we put a reference and return a TTY! */

1832

/* This is only safe because the caller holds tty_mutex */

1832

/* This is only safe because the caller holds tty_mutex */

1833

return tty;

1833

return tty;

1834

}

1834

}

1835

1836

/**

1836

/**

1837

* tty_lookup_driver - lookup a tty driver for a given device file

1837

* tty_lookup_driver - lookup a tty driver for a given device file

1838

* @device: device number

1838

* @device: device number

1839

* @filp: file pointer to tty

1839

* @filp: file pointer to tty

1840

* @noctty: set if the device should not become a controlling tty

1840

* @noctty: set if the device should not become a controlling tty

1841

* @index: index for the device in the @return driver

1841

* @index: index for the device in the @return driver

1842

* @return: driver for this inode (with increased refcount)

1842

* @return: driver for this inode (with increased refcount)

1843

*

1843

*

1844

* If @return is not erroneous, the caller is responsible to decrement the

1844

* If @return is not erroneous, the caller is responsible to decrement the

1845

* refcount by tty_driver_kref_put.

1845

* refcount by tty_driver_kref_put.

1846

*

1846

*

1847

* Locking: tty_mutex protects get_tty_driver

1847

* Locking: tty_mutex protects get_tty_driver

1848

*/

1848

*/

1849

static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,

1849

static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,

1850

int *noctty, int *index)

1850

int *noctty, int *index)

1851

{

1851

{

1852

struct tty_driver *driver;

1852

struct tty_driver *driver;

1853

1854

switch (device) {

1854

switch (device) {

1855

#ifdef CONFIG_VT

1855

#ifdef CONFIG_VT

1856

case MKDEV(TTY_MAJOR, 0): {

1856

case MKDEV(TTY_MAJOR, 0): {

1857

extern struct tty_driver *console_driver;

1857

extern struct tty_driver *console_driver;

1858

driver = tty_driver_kref_get(console_driver);

1858

driver = tty_driver_kref_get(console_driver);

1859

*index = fg_console;

1859

*index = fg_console;

1860

*noctty = 1;

1860

*noctty = 1;

1861

break;

1861

break;

1862

}

1862

}

1863

#endif

1863

#endif

1864

case MKDEV(TTYAUX_MAJOR, 1): {

1864

case MKDEV(TTYAUX_MAJOR, 1): {

1865

struct tty_driver *console_driver = console_device(index);

1865

struct tty_driver *console_driver = console_device(index);

1866

if (console_driver) {

1866

if (console_driver) {

1867

driver = tty_driver_kref_get(console_driver);

1867

driver = tty_driver_kref_get(console_driver);

1868

if (driver) {

1868

if (driver) {

1869

/* Don't let /dev/console block */

1869

/* Don't let /dev/console block */

1870

filp->f_flags |= O_NONBLOCK;

1870

filp->f_flags |= O_NONBLOCK;

1871

*noctty = 1;

1871

*noctty = 1;

1872

break;

1872

break;

1873

}

1873

}

1874

}

1874

}

1875

return ERR_PTR(-ENODEV);

1875

return ERR_PTR(-ENODEV);

1876

}

1876

}

1877

default:

1877

default:

1878

driver = get_tty_driver(device, index);

1878

driver = get_tty_driver(device, index);

1879

if (!driver)

1879

if (!driver)

1880

return ERR_PTR(-ENODEV);

1880

return ERR_PTR(-ENODEV);

1881

break;

1881

break;

1882

}

1882

}

1883

return driver;

1883

return driver;

1884

}

1884

}

1885

1886

/**

1886

/**

1887

* tty_open - open a tty device

1887

* tty_open - open a tty device

1888

* @inode: inode of device file

1888

* @inode: inode of device file

1889

* @filp: file pointer to tty

1889

* @filp: file pointer to tty

1890

*

1890

*

1891

* tty_open and tty_release keep up the tty count that contains the

1891

* tty_open and tty_release keep up the tty count that contains the

1892

* number of opens done on a tty. We cannot use the inode-count, as

1892

* number of opens done on a tty. We cannot use the inode-count, as

1893

* different inodes might point to the same tty.

1893

* different inodes might point to the same tty.

1894

*

1894

*

1895

* Open-counting is needed for pty masters, as well as for keeping

1895

* Open-counting is needed for pty masters, as well as for keeping

1896

* track of serial lines: DTR is dropped when the last close happens.

1896

* track of serial lines: DTR is dropped when the last close happens.

1897

* (This is not done solely through tty->count, now. - Ted 1/27/92)

1897

* (This is not done solely through tty->count, now. - Ted 1/27/92)

1898

*

1898

*

1899

* The termios state of a pty is reset on first open so that

1899

* The termios state of a pty is reset on first open so that

1900

* settings don't persist across reuse.

1900

* settings don't persist across reuse.

1901

*

1901

*

1902

* Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.

1902

* Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.

1903

* tty->count should protect the rest.

1903

* tty->count should protect the rest.

1904

* ->siglock protects ->signal/->sighand

1904

* ->siglock protects ->signal/->sighand

1905

*

1905

*

1906

* Note: the tty_unlock/lock cases without a ref are only safe due to

1906

* Note: the tty_unlock/lock cases without a ref are only safe due to

1907

* tty_mutex

1907

* tty_mutex

1908

*/

1908

*/

1909

1910

static int tty_open(struct inode *inode, struct file *filp)

1910

static int tty_open(struct inode *inode, struct file *filp)

1911

{

1911

{

1912

struct tty_struct *tty;

1912

struct tty_struct *tty;

1913

int noctty, retval;

1913

int noctty, retval;

1914

struct tty_driver *driver = NULL;

1914

struct tty_driver *driver = NULL;

1915

int index;

1915

int index;

1916

dev_t device = inode->i_rdev;

1916

dev_t device = inode->i_rdev;

1917

unsigned saved_flags = filp->f_flags;

1917

unsigned saved_flags = filp->f_flags;

1918

1919

nonseekable_open(inode, filp);

1919

nonseekable_open(inode, filp);

1920

1921

retry_open:

1921

retry_open:

1922

retval = tty_alloc_file(filp);

1922

retval = tty_alloc_file(filp);

1923

if (retval)

1923

if (retval)

1924

return -ENOMEM;

1924

return -ENOMEM;

1925

1926

noctty = filp->f_flags & O_NOCTTY;

1926

noctty = filp->f_flags & O_NOCTTY;

1927

index = -1;

1927

index = -1;

1928

retval = 0;

1928

retval = 0;

1929

1930

mutex_lock(&tty_mutex);

1930

mutex_lock(&tty_mutex);

1931

/* This is protected by the tty_mutex */

1931

/* This is protected by the tty_mutex */

1932

tty = tty_open_current_tty(device, filp);

1932

tty = tty_open_current_tty(device, filp);

1933

if (IS_ERR(tty)) {

1933

if (IS_ERR(tty)) {

1934

retval = PTR_ERR(tty);

1934

retval = PTR_ERR(tty);

1935

goto err_unlock;

1935

goto err_unlock;

1936

} else if (!tty) {

1936

} else if (!tty) {

1937

driver = tty_lookup_driver(device, filp, &noctty, &index);

1937

driver = tty_lookup_driver(device, filp, &noctty, &index);

1938

if (IS_ERR(driver)) {

1938

if (IS_ERR(driver)) {

1939

retval = PTR_ERR(driver);

1939

retval = PTR_ERR(driver);

1940

goto err_unlock;

1940

goto err_unlock;

1941

}

1941

}

1942

1943

/* check whether we're reopening an existing tty */

1943

/* check whether we're reopening an existing tty */

1944

tty = tty_driver_lookup_tty(driver, inode, index);

1944

tty = tty_driver_lookup_tty(driver, inode, index);

1945

if (IS_ERR(tty)) {

1945

if (IS_ERR(tty)) {

1946

retval = PTR_ERR(tty);

1946

retval = PTR_ERR(tty);

1947

goto err_unlock;

1947

goto err_unlock;

1948

}

1948

}

1949

}

1949

}

1950

1951

if (tty) {

1951

if (tty) {

1952

tty_lock(tty);

1952

tty_lock(tty);

1953

retval = tty_reopen(tty);

1953

retval = tty_reopen(tty);

1954

if (retval < 0) {

1954

if (retval < 0) {

1955

tty_unlock(tty);

1955

tty_unlock(tty);

1956

tty = ERR_PTR(retval);

1956

tty = ERR_PTR(retval);

1957

}

1957

}

1958

} else /* Returns with the tty_lock held for now */

1958

} else /* Returns with the tty_lock held for now */

1959

tty = tty_init_dev(driver, index);

1959

tty = tty_init_dev(driver, index);

1960

1961

mutex_unlock(&tty_mutex);

1961

mutex_unlock(&tty_mutex);

1962

if (driver)

1962

if (driver)

1963

tty_driver_kref_put(driver);

1963

tty_driver_kref_put(driver);

1964

if (IS_ERR(tty)) {

1964

if (IS_ERR(tty)) {

1965

retval = PTR_ERR(tty);

1965

retval = PTR_ERR(tty);

1966

goto err_file;

1966

goto err_file;

1967

}

1967

}

1968

1969

tty_add_file(tty, filp);

1969

tty_add_file(tty, filp);

1970

1971

check_tty_count(tty, __func__);

1971

check_tty_count(tty, __func__);

1972

if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&

1972

if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&

1973

tty->driver->subtype == PTY_TYPE_MASTER)

1973

tty->driver->subtype == PTY_TYPE_MASTER)

1974

noctty = 1;

1974

noctty = 1;

1975

#ifdef TTY_DEBUG_HANGUP

1975

#ifdef TTY_DEBUG_HANGUP

1976

printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);

1976

printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);

1977

#endif

1977

#endif

1978

if (tty->ops->open)

1978

if (tty->ops->open)

1979

retval = tty->ops->open(tty, filp);

1979

retval = tty->ops->open(tty, filp);

1980

else

1980

else

1981

retval = -ENODEV;

1981

retval = -ENODEV;

1982

filp->f_flags = saved_flags;

1982

filp->f_flags = saved_flags;

1983

1984

if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&

1984

if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&

1985

!capable(CAP_SYS_ADMIN))

1985

!capable(CAP_SYS_ADMIN))

1986

retval = -EBUSY;

1986

retval = -EBUSY;

1987

1988

if (retval) {

1988

if (retval) {

1989

#ifdef TTY_DEBUG_HANGUP

1989

#ifdef TTY_DEBUG_HANGUP

1990

printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,

1990

printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,

1991

retval, tty->name);

1991

retval, tty->name);

1992

#endif

1992

#endif

1993

tty_unlock(tty); /* need to call tty_release without BTM */

1993

tty_unlock(tty); /* need to call tty_release without BTM */

1994

tty_release(inode, filp);

1994

tty_release(inode, filp);

1995

if (retval != -ERESTARTSYS)

1995

if (retval != -ERESTARTSYS)

1996

return retval;

1996

return retval;

1997

1998

if (signal_pending(current))

1998

if (signal_pending(current))

1999

return retval;

1999

return retval;

2000

2001

schedule();

2001

schedule();

2002

/*

2002

/*

2003

* Need to reset f_op in case a hangup happened.

2003

* Need to reset f_op in case a hangup happened.

2004

*/

2004

*/

2005

if (filp->f_op == &hung_up_tty_fops)

2005

if (filp->f_op == &hung_up_tty_fops)

2006

filp->f_op = &tty_fops;

2006

filp->f_op = &tty_fops;

2007

goto retry_open;

2007

goto retry_open;

2008

}

2008

}

2009

tty_unlock(tty);

2009

tty_unlock(tty);

2010

2011

2012

mutex_lock(&tty_mutex);

2012

mutex_lock(&tty_mutex);

2013

tty_lock(tty);

2013

tty_lock(tty);

2014

spin_lock_irq(&current->sighand->siglock);

2014

spin_lock_irq(&current->sighand->siglock);

2015

if (!noctty &&

2015

if (!noctty &&

2016

current->signal->leader &&

2016

current->signal->leader &&

2017

!current->signal->tty &&

2017

!current->signal->tty &&

2018

tty->session == NULL)

2018

tty->session == NULL)

2019

__proc_set_tty(current, tty);

2019

__proc_set_tty(current, tty);

2020

spin_unlock_irq(&current->sighand->siglock);

2020

spin_unlock_irq(&current->sighand->siglock);

2021

tty_unlock(tty);

2021

tty_unlock(tty);

2022

mutex_unlock(&tty_mutex);

2022

mutex_unlock(&tty_mutex);

2023

return 0;

2023

return 0;

2024

err_unlock:

2024

err_unlock:

2025

mutex_unlock(&tty_mutex);

2025

mutex_unlock(&tty_mutex);

2026

/* after locks to avoid deadlock */

2026

/* after locks to avoid deadlock */

2027

if (!IS_ERR_OR_NULL(driver))

2027

if (!IS_ERR_OR_NULL(driver))

2028

tty_driver_kref_put(driver);

2028

tty_driver_kref_put(driver);

2029

err_file:

2029

err_file:

2030

tty_free_file(filp);

2030

tty_free_file(filp);

2031

return retval;

2031

return retval;

2032

}

2032

}

2033

2034

2035

2036

/**

2036

/**

2037

* tty_poll - check tty status

2037

* tty_poll - check tty status

2038

* @filp: file being polled

2038

* @filp: file being polled

2039

* @wait: poll wait structures to update

2039

* @wait: poll wait structures to update

2040

*

2040

*

2041

* Call the line discipline polling method to obtain the poll

2041

* Call the line discipline polling method to obtain the poll

2042

* status of the device.

2042

* status of the device.

2043

*

2043

*

2044

* Locking: locks called line discipline but ldisc poll method

2044

* Locking: locks called line discipline but ldisc poll method

2045

* may be re-entered freely by other callers.

2045

* may be re-entered freely by other callers.

2046

*/

2046

*/

2047

2048

static unsigned int tty_poll(struct file *filp, poll_table *wait)

2048

static unsigned int tty_poll(struct file *filp, poll_table *wait)

2049

{

2049

{

2050

struct tty_struct *tty = file_tty(filp);

2050

struct tty_struct *tty = file_tty(filp);

2051

struct tty_ldisc *ld;

2051

struct tty_ldisc *ld;

2052

int ret = 0;

2052

int ret = 0;

2053

2054

if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))

2054

if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))

2055

return 0;

2055

return 0;

2056

2057

ld = tty_ldisc_ref_wait(tty);

2057

ld = tty_ldisc_ref_wait(tty);

2058

if (ld->ops->poll)

2058

if (ld->ops->poll)

2059

ret = (ld->ops->poll)(tty, filp, wait);

2059

ret = (ld->ops->poll)(tty, filp, wait);

2060

tty_ldisc_deref(ld);

2060

tty_ldisc_deref(ld);

2061

return ret;

2061

return ret;

2062

}

2062

}

2063

2064

static int __tty_fasync(int fd, struct file *filp, int on)

2064

static int __tty_fasync(int fd, struct file *filp, int on)

2065

{

2065

{

2066

struct tty_struct *tty = file_tty(filp);

2066

struct tty_struct *tty = file_tty(filp);

2067

unsigned long flags;

2067

unsigned long flags;

2068

int retval = 0;

2068

int retval = 0;

2069

2070

if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))

2070

if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))

2071

goto out;

2071

goto out;

2072

2073

retval = fasync_helper(fd, filp, on, &tty->fasync);

2073

retval = fasync_helper(fd, filp, on, &tty->fasync);

2074

if (retval <= 0)

2074

if (retval <= 0)

2075

goto out;

2075

goto out;

2076

2077

if (on) {

2077

if (on) {

2078

enum pid_type type;

2078

enum pid_type type;

2079

struct pid *pid;

2079

struct pid *pid;

2080

if (!waitqueue_active(&tty->read_wait))

2080

if (!waitqueue_active(&tty->read_wait))

2081

tty->minimum_to_wake = 1;

2081

tty->minimum_to_wake = 1;

2082

spin_lock_irqsave(&tty->ctrl_lock, flags);

2082

spin_lock_irqsave(&tty->ctrl_lock, flags);

2083

if (tty->pgrp) {

2083

if (tty->pgrp) {

2084

pid = tty->pgrp;

2084

pid = tty->pgrp;

2085

type = PIDTYPE_PGID;

2085

type = PIDTYPE_PGID;

2086

} else {

2086

} else {

2087

pid = task_pid(current);

2087

pid = task_pid(current);

2088

type = PIDTYPE_PID;

2088

type = PIDTYPE_PID;

2089

}

2089

}

2090

get_pid(pid);

2090

get_pid(pid);

2091

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

2091

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

2092

retval = __f_setown(filp, pid, type, 0);

2092

retval = __f_setown(filp, pid, type, 0);

2093

put_pid(pid);

2093

put_pid(pid);

2094

if (retval)

2094

if (retval)

2095

goto out;

2095

goto out;

2096

} else {

2096

} else {

2097

if (!tty->fasync && !waitqueue_active(&tty->read_wait))

2097

if (!tty->fasync && !waitqueue_active(&tty->read_wait))

2098

tty->minimum_to_wake = N_TTY_BUF_SIZE;

2098

tty->minimum_to_wake = N_TTY_BUF_SIZE;

2099

}

2099

}

2100

retval = 0;

2100

retval = 0;

2101

out:

2101

out:

2102

return retval;

2102

return retval;

2103

}

2103

}

2104

2105

static int tty_fasync(int fd, struct file *filp, int on)

2105

static int tty_fasync(int fd, struct file *filp, int on)

2106

{

2106

{

2107

struct tty_struct *tty = file_tty(filp);

2107

struct tty_struct *tty = file_tty(filp);

2108

int retval;

2108

int retval;

2109

2110

tty_lock(tty);

2110

tty_lock(tty);

2111

retval = __tty_fasync(fd, filp, on);

2111

retval = __tty_fasync(fd, filp, on);

2112

tty_unlock(tty);

2112

tty_unlock(tty);

2113

2114

return retval;

2114

return retval;

2115

}

2115

}

2116

2117

/**

2117

/**

2118

* tiocsti - fake input character

2118

* tiocsti - fake input character

2119

* @tty: tty to fake input into

2119

* @tty: tty to fake input into

2120

* @p: pointer to character

2120

* @p: pointer to character

2121

*

2121

*

2122

* Fake input to a tty device. Does the necessary locking and

2122

* Fake input to a tty device. Does the necessary locking and

2123

* input management.

2123

* input management.

2124

*

2124

*

2125

* FIXME: does not honour flow control ??

2125

* FIXME: does not honour flow control ??

2126

*

2126

*

2127

* Locking:

2127

* Locking:

2128

* Called functions take tty_ldisc_lock

2128

* Called functions take tty_ldisc_lock

2129

* current->signal->tty check is safe without locks

2129

* current->signal->tty check is safe without locks

2130

*

2130

*

2131

* FIXME: may race normal receive processing

2131

* FIXME: may race normal receive processing

2132

*/

2132

*/

2133

2134

static int tiocsti(struct tty_struct *tty, char __user *p)

2134

static int tiocsti(struct tty_struct *tty, char __user *p)

2135

{

2135

{

2136

char ch, mbz = 0;

2136

char ch, mbz = 0;

2137

struct tty_ldisc *ld;

2137

struct tty_ldisc *ld;

2138

2139

if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))

2139

if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))

2140

return -EPERM;

2140

return -EPERM;

2141

if (get_user(ch, p))

2141

if (get_user(ch, p))

2142

return -EFAULT;

2142

return -EFAULT;

2143

tty_audit_tiocsti(tty, ch);

2143

tty_audit_tiocsti(tty, ch);

2144

ld = tty_ldisc_ref_wait(tty);

2144

ld = tty_ldisc_ref_wait(tty);

2145

ld->ops->receive_buf(tty, &ch, &mbz, 1);

2145

ld->ops->receive_buf(tty, &ch, &mbz, 1);

2146

tty_ldisc_deref(ld);

2146

tty_ldisc_deref(ld);

2147

return 0;

2147

return 0;

2148

}

2148

}

2149

2150

/**

2150

/**

2151

* tiocgwinsz - implement window query ioctl

2151

* tiocgwinsz - implement window query ioctl

2152

* @tty; tty

2152

* @tty; tty

2153

* @arg: user buffer for result

2153

* @arg: user buffer for result

2154

*

2154

*

2155

* Copies the kernel idea of the window size into the user buffer.

2155

* Copies the kernel idea of the window size into the user buffer.

2156

*

2156

*

2157

* Locking: tty->termios_mutex is taken to ensure the winsize data

2157

* Locking: tty->termios_mutex is taken to ensure the winsize data

2158

* is consistent.

2158

* is consistent.

2159

*/

2159

*/

2160

2161

static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)

2161

static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)

2162

{

2162

{

2163

int err;

2163

int err;

2164

2165

mutex_lock(&tty->termios_mutex);

2165

mutex_lock(&tty->termios_mutex);

2166

err = copy_to_user(arg, &tty->winsize, sizeof(*arg));

2166

err = copy_to_user(arg, &tty->winsize, sizeof(*arg));

2167

mutex_unlock(&tty->termios_mutex);

2167

mutex_unlock(&tty->termios_mutex);

2168

2169

return err ? -EFAULT: 0;

2169

return err ? -EFAULT: 0;

2170

}

2170

}

2171

2172

/**

2172

/**

2173

* tty_do_resize - resize event

2173

* tty_do_resize - resize event

2174

* @tty: tty being resized

2174

* @tty: tty being resized

2175

* @rows: rows (character)

2175

* @rows: rows (character)

2176

* @cols: cols (character)

2176

* @cols: cols (character)

2177

*

2177

*

2178

* Update the termios variables and send the necessary signals to

2178

* Update the termios variables and send the necessary signals to

2179

* peform a terminal resize correctly

2179

* peform a terminal resize correctly

2180

*/

2180

*/

2181

2182

int tty_do_resize(struct tty_struct *tty, struct winsize *ws)

2182

int tty_do_resize(struct tty_struct *tty, struct winsize *ws)

2183

{

2183

{

2184

struct pid *pgrp;

2184

struct pid *pgrp;

2185

unsigned long flags;

2185

unsigned long flags;

2186

2187

/* Lock the tty */

2187

/* Lock the tty */

2188

mutex_lock(&tty->termios_mutex);

2188

mutex_lock(&tty->termios_mutex);

2189

if (!memcmp(ws, &tty->winsize, sizeof(*ws)))

2189

if (!memcmp(ws, &tty->winsize, sizeof(*ws)))

2190

goto done;

2190

goto done;

2191

/* Get the PID values and reference them so we can

2191

/* Get the PID values and reference them so we can

2192

avoid holding the tty ctrl lock while sending signals */

2192

avoid holding the tty ctrl lock while sending signals */

2193

spin_lock_irqsave(&tty->ctrl_lock, flags);

2193

spin_lock_irqsave(&tty->ctrl_lock, flags);

2194

pgrp = get_pid(tty->pgrp);

2194

pgrp = get_pid(tty->pgrp);

2195

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

2195

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

2196

2197

if (pgrp)

2197

if (pgrp)

2198

kill_pgrp(pgrp, SIGWINCH, 1);

2198

kill_pgrp(pgrp, SIGWINCH, 1);

2199

put_pid(pgrp);

2199

put_pid(pgrp);

2200

2201

tty->winsize = *ws;

2201

tty->winsize = *ws;

2202

done:

2202

done:

2203

mutex_unlock(&tty->termios_mutex);

2203

mutex_unlock(&tty->termios_mutex);

2204

return 0;

2204

return 0;

2205

}

2205

}

2206

2207

/**

2207

/**

2208

* tiocswinsz - implement window size set ioctl

2208

* tiocswinsz - implement window size set ioctl

2209

* @tty; tty side of tty

2209

* @tty; tty side of tty

2210

* @arg: user buffer for result

2210

* @arg: user buffer for result

2211

*

2211

*

2212

* Copies the user idea of the window size to the kernel. Traditionally

2212

* Copies the user idea of the window size to the kernel. Traditionally

2213

* this is just advisory information but for the Linux console it

2213

* this is just advisory information but for the Linux console it

2214

* actually has driver level meaning and triggers a VC resize.

2214

* actually has driver level meaning and triggers a VC resize.

2215

*

2215

*

2216

* Locking:

2216

* Locking:

2217

* Driver dependent. The default do_resize method takes the

2217

* Driver dependent. The default do_resize method takes the

2218

* tty termios mutex and ctrl_lock. The console takes its own lock

2218

* tty termios mutex and ctrl_lock. The console takes its own lock

2219

* then calls into the default method.

2219

* then calls into the default method.

2220

*/

2220

*/

2221

2222

static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)

2222

static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)

2223

{

2223

{

2224

struct winsize tmp_ws;

2224

struct winsize tmp_ws;

2225

if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))

2225

if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))

2226

return -EFAULT;

2226

return -EFAULT;

2227

2228

if (tty->ops->resize)

2228

if (tty->ops->resize)

2229

return tty->ops->resize(tty, &tmp_ws);

2229

return tty->ops->resize(tty, &tmp_ws);

2230

else

2230

else

2231

return tty_do_resize(tty, &tmp_ws);

2231

return tty_do_resize(tty, &tmp_ws);

2232

}

2232

}

2233

2234

/**

2234

/**

2235

* tioccons - allow admin to move logical console

2235

* tioccons - allow admin to move logical console

2236

* @file: the file to become console

2236

* @file: the file to become console

2237

*

2237

*

2238

* Allow the administrator to move the redirected console device

2238

* Allow the administrator to move the redirected console device

2239

*

2239

*

2240

* Locking: uses redirect_lock to guard the redirect information

2240

* Locking: uses redirect_lock to guard the redirect information

2241

*/

2241

*/

2242

2243

static int tioccons(struct file *file)

2243

static int tioccons(struct file *file)

2244

{

2244

{

2245

if (!capable(CAP_SYS_ADMIN))

2245

if (!capable(CAP_SYS_ADMIN))

2246

return -EPERM;

2246

return -EPERM;

2247

if (file->f_op->write == redirected_tty_write) {

2247

if (file->f_op->write == redirected_tty_write) {

2248

struct file *f;

2248

struct file *f;

2249

spin_lock(&redirect_lock);

2249

spin_lock(&redirect_lock);

2250

f = redirect;

2250

f = redirect;

2251

redirect = NULL;

2251

redirect = NULL;

2252

spin_unlock(&redirect_lock);

2252

spin_unlock(&redirect_lock);

2253

if (f)

2253

if (f)

2254

fput(f);

2254

fput(f);

2255

return 0;

2255

return 0;

2256

}

2256

}

2257

spin_lock(&redirect_lock);

2257

spin_lock(&redirect_lock);

2258

if (redirect) {

2258

if (redirect) {

2259

spin_unlock(&redirect_lock);

2259

spin_unlock(&redirect_lock);

2260

return -EBUSY;

2260

return -EBUSY;

2261

}

2261

}

2262

redirect = get_file(file);

2262

redirect = get_file(file);

2263

spin_unlock(&redirect_lock);

2263

spin_unlock(&redirect_lock);

2264

return 0;

2264

return 0;

2265

}

2265

}

2266

2267

/**

2267

/**

2268

* fionbio - non blocking ioctl

2268

* fionbio - non blocking ioctl

2269

* @file: file to set blocking value

2269

* @file: file to set blocking value

2270

* @p: user parameter

2270

* @p: user parameter

2271

*

2271

*

2272

* Historical tty interfaces had a blocking control ioctl before

2272

* Historical tty interfaces had a blocking control ioctl before

2273

* the generic functionality existed. This piece of history is preserved

2273

* the generic functionality existed. This piece of history is preserved

2274

* in the expected tty API of posix OS's.

2274

* in the expected tty API of posix OS's.

2275

*

2275

*

2276

* Locking: none, the open file handle ensures it won't go away.

2276

* Locking: none, the open file handle ensures it won't go away.

2277

*/

2277

*/

2278

2279

static int fionbio(struct file *file, int __user *p)

2279

static int fionbio(struct file *file, int __user *p)

2280

{

2280

{

2281

int nonblock;

2281

int nonblock;

2282

2283

if (get_user(nonblock, p))

2283

if (get_user(nonblock, p))

2284

return -EFAULT;

2284

return -EFAULT;

2285

2286

spin_lock(&file->f_lock);

2286

spin_lock(&file->f_lock);

2287

if (nonblock)

2287

if (nonblock)

2288

file->f_flags |= O_NONBLOCK;

2288

file->f_flags |= O_NONBLOCK;

2289

else

2289

else

2290

file->f_flags &= ~O_NONBLOCK;

2290

file->f_flags &= ~O_NONBLOCK;

2291

spin_unlock(&file->f_lock);

2291

spin_unlock(&file->f_lock);

2292

return 0;

2292

return 0;

2293

}

2293

}

2294

2295

/**

2295

/**

2296

* tiocsctty - set controlling tty

2296

* tiocsctty - set controlling tty

2297

* @tty: tty structure

2297

* @tty: tty structure

2298

* @arg: user argument

2298

* @arg: user argument

2299

*

2299

*

2300

* This ioctl is used to manage job control. It permits a session

2300

* This ioctl is used to manage job control. It permits a session

2301

* leader to set this tty as the controlling tty for the session.

2301

* leader to set this tty as the controlling tty for the session.

2302

*

2302

*

2303

* Locking:

2303

* Locking:

2304

* Takes tty_mutex() to protect tty instance

2304

* Takes tty_mutex() to protect tty instance

2305

* Takes tasklist_lock internally to walk sessions

2305

* Takes tasklist_lock internally to walk sessions

2306

* Takes ->siglock() when updating signal->tty

2306

* Takes ->siglock() when updating signal->tty

2307

*/

2307

*/

2308

2309

static int tiocsctty(struct tty_struct *tty, int arg)

2309

static int tiocsctty(struct tty_struct *tty, int arg)

2310

{

2310

{

2311

int ret = 0;

2311

int ret = 0;

2312

if (current->signal->leader && (task_session(current) == tty->session))

2312

if (current->signal->leader && (task_session(current) == tty->session))

2313

return ret;

2313

return ret;

2314

2315

mutex_lock(&tty_mutex);

2315

mutex_lock(&tty_mutex);

2316

/*

2316

/*

2317

* The process must be a session leader and

2317

* The process must be a session leader and

2318

* not have a controlling tty already.

2318

* not have a controlling tty already.

2319

*/

2319

*/

2320

if (!current->signal->leader || current->signal->tty) {

2320

if (!current->signal->leader || current->signal->tty) {

2321

ret = -EPERM;

2321

ret = -EPERM;

2322

goto unlock;

2322

goto unlock;

2323

}

2323

}

2324

2325

if (tty->session) {

2325

if (tty->session) {

2326

/*

2326

/*

2327

* This tty is already the controlling

2327

* This tty is already the controlling

2328

* tty for another session group!

2328

* tty for another session group!

2329

*/

2329

*/

2330

if (arg == 1 && capable(CAP_SYS_ADMIN)) {

2330

if (arg == 1 && capable(CAP_SYS_ADMIN)) {

2331

/*

2331

/*

2332

* Steal it away

2332

* Steal it away

2333

*/

2333

*/

2334

read_lock(&tasklist_lock);

2334

read_lock(&tasklist_lock);

2335

session_clear_tty(tty->session);

2335

session_clear_tty(tty->session);

2336

read_unlock(&tasklist_lock);

2336

read_unlock(&tasklist_lock);

2337

} else {

2337

} else {

2338

ret = -EPERM;

2338

ret = -EPERM;

2339

goto unlock;

2339

goto unlock;

2340

}

2340

}

2341

}

2341

}

2342

proc_set_tty(current, tty);

2342

proc_set_tty(current, tty);

2343

unlock:

2343

unlock:

2344

mutex_unlock(&tty_mutex);

2344

mutex_unlock(&tty_mutex);

2345

return ret;

2345

return ret;

2346

}

2346

}

2347

2348

/**

2348

/**

2349

* tty_get_pgrp - return a ref counted pgrp pid

2349

* tty_get_pgrp - return a ref counted pgrp pid

2350

* @tty: tty to read

2350

* @tty: tty to read

2351

*

2351

*

2352

* Returns a refcounted instance of the pid struct for the process

2352

* Returns a refcounted instance of the pid struct for the process

2353

* group controlling the tty.

2353

* group controlling the tty.

2354

*/

2354

*/

2355

2356

struct pid *tty_get_pgrp(struct tty_struct *tty)

2356

struct pid *tty_get_pgrp(struct tty_struct *tty)

2357

{

2357

{

2358

unsigned long flags;

2358

unsigned long flags;

2359

struct pid *pgrp;

2359

struct pid *pgrp;

2360

2361

spin_lock_irqsave(&tty->ctrl_lock, flags);

2361

spin_lock_irqsave(&tty->ctrl_lock, flags);

2362

pgrp = get_pid(tty->pgrp);

2362

pgrp = get_pid(tty->pgrp);

2363

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

2363

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

2364

2365

return pgrp;

2365

return pgrp;

2366

}

2366

}

2367

EXPORT_SYMBOL_GPL(tty_get_pgrp);

2367

EXPORT_SYMBOL_GPL(tty_get_pgrp);

2368

2369

/**

2369

/**

2370

* tiocgpgrp - get process group

2370

* tiocgpgrp - get process group

2371

* @tty: tty passed by user

2371

* @tty: tty passed by user

2372

* @real_tty: tty side of the tty passed by the user if a pty else the tty

2372

* @real_tty: tty side of the tty passed by the user if a pty else the tty

2373

* @p: returned pid

2373

* @p: returned pid

2374

*

2374

*

2375

* Obtain the process group of the tty. If there is no process group

2375

* Obtain the process group of the tty. If there is no process group

2376

* return an error.

2376

* return an error.

2377

*

2377

*

2378

* Locking: none. Reference to current->signal->tty is safe.

2378

* Locking: none. Reference to current->signal->tty is safe.

2379

*/

2379

*/

2380

2381

static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)

2381

static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)

2382

{

2382

{

2383

struct pid *pid;

2383

struct pid *pid;

2384

int ret;

2384

int ret;

2385

/*

2385

/*

2386

* (tty == real_tty) is a cheap way of

2386

* (tty == real_tty) is a cheap way of

2387

* testing if the tty is NOT a master pty.

2387

* testing if the tty is NOT a master pty.

2388

*/

2388

*/

2389

if (tty == real_tty && current->signal->tty != real_tty)

2389

if (tty == real_tty && current->signal->tty != real_tty)

2390

return -ENOTTY;

2390

return -ENOTTY;

2391

pid = tty_get_pgrp(real_tty);

2391

pid = tty_get_pgrp(real_tty);

2392

ret = put_user(pid_vnr(pid), p);

2392

ret = put_user(pid_vnr(pid), p);

2393

put_pid(pid);

2393

put_pid(pid);

2394

return ret;

2394

return ret;

2395

}

2395

}

2396

2397

/**

2397

/**

2398

* tiocspgrp - attempt to set process group

2398

* tiocspgrp - attempt to set process group

2399

* @tty: tty passed by user

2399

* @tty: tty passed by user

2400

* @real_tty: tty side device matching tty passed by user

2400

* @real_tty: tty side device matching tty passed by user

2401

* @p: pid pointer

2401

* @p: pid pointer

2402

*

2402

*

2403

* Set the process group of the tty to the session passed. Only

2403

* Set the process group of the tty to the session passed. Only

2404

* permitted where the tty session is our session.

2404

* permitted where the tty session is our session.

2405

*

2405

*

2406

* Locking: RCU, ctrl lock

2406

* Locking: RCU, ctrl lock

2407

*/

2407

*/

2408

2409

static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)

2409

static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)

2410

{

2410

{

2411

struct pid *pgrp;

2411

struct pid *pgrp;

2412

pid_t pgrp_nr;

2412

pid_t pgrp_nr;

2413

int retval = tty_check_change(real_tty);

2413

int retval = tty_check_change(real_tty);

2414

unsigned long flags;

2414

unsigned long flags;

2415

2416

if (retval == -EIO)

2416

if (retval == -EIO)

2417

return -ENOTTY;

2417

return -ENOTTY;

2418

if (retval)

2418

if (retval)

2419

return retval;

2419

return retval;

2420

if (!current->signal->tty ||

2420

if (!current->signal->tty ||

2421

(current->signal->tty != real_tty) ||

2421

(current->signal->tty != real_tty) ||

2422

(real_tty->session != task_session(current)))

2422

(real_tty->session != task_session(current)))

2423

return -ENOTTY;

2423

return -ENOTTY;

2424

if (get_user(pgrp_nr, p))

2424

if (get_user(pgrp_nr, p))

2425

return -EFAULT;

2425

return -EFAULT;

2426

if (pgrp_nr < 0)

2426

if (pgrp_nr < 0)

2427

return -EINVAL;

2427

return -EINVAL;

2428

rcu_read_lock();

2428

rcu_read_lock();

2429

pgrp = find_vpid(pgrp_nr);

2429

pgrp = find_vpid(pgrp_nr);

2430

retval = -ESRCH;

2430

retval = -ESRCH;

2431

if (!pgrp)

2431

if (!pgrp)

2432

goto out_unlock;

2432

goto out_unlock;

2433

retval = -EPERM;

2433

retval = -EPERM;

2434

if (session_of_pgrp(pgrp) != task_session(current))

2434

if (session_of_pgrp(pgrp) != task_session(current))

2435

goto out_unlock;

2435

goto out_unlock;

2436

retval = 0;

2436

retval = 0;

2437

spin_lock_irqsave(&tty->ctrl_lock, flags);

2437

spin_lock_irqsave(&tty->ctrl_lock, flags);

2438

put_pid(real_tty->pgrp);

2438

put_pid(real_tty->pgrp);

2439

real_tty->pgrp = get_pid(pgrp);

2439

real_tty->pgrp = get_pid(pgrp);

2440

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

2440

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

2441

out_unlock:

2441

out_unlock:

2442

rcu_read_unlock();

2442

rcu_read_unlock();

2443

return retval;

2443

return retval;

2444

}

2444

}

2445

2446

/**

2446

/**

2447

* tiocgsid - get session id

2447

* tiocgsid - get session id

2448

* @tty: tty passed by user

2448

* @tty: tty passed by user

2449

* @real_tty: tty side of the tty passed by the user if a pty else the tty

2449

* @real_tty: tty side of the tty passed by the user if a pty else the tty

2450

* @p: pointer to returned session id

2450

* @p: pointer to returned session id

2451

*

2451

*

2452

* Obtain the session id of the tty. If there is no session

2452

* Obtain the session id of the tty. If there is no session

2453

* return an error.

2453

* return an error.

2454

*

2454

*

2455

* Locking: none. Reference to current->signal->tty is safe.

2455

* Locking: none. Reference to current->signal->tty is safe.

2456

*/

2456

*/

2457

2458

static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)

2458

static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)

2459

{

2459

{

2460

/*

2460

/*

2461

* (tty == real_tty) is a cheap way of

2461

* (tty == real_tty) is a cheap way of

2462

* testing if the tty is NOT a master pty.

2462

* testing if the tty is NOT a master pty.

2463

*/

2463

*/

2464

if (tty == real_tty && current->signal->tty != real_tty)

2464

if (tty == real_tty && current->signal->tty != real_tty)

2465

return -ENOTTY;

2465

return -ENOTTY;

2466

if (!real_tty->session)

2466

if (!real_tty->session)

2467

return -ENOTTY;

2467

return -ENOTTY;

2468

return put_user(pid_vnr(real_tty->session), p);

2468

return put_user(pid_vnr(real_tty->session), p);

2469

}

2469

}

2470

2471

/**

2471

/**

2472

* tiocsetd - set line discipline

2472

* tiocsetd - set line discipline

2473

* @tty: tty device

2473

* @tty: tty device

2474

* @p: pointer to user data

2474

* @p: pointer to user data

2475

*

2475

*

2476

* Set the line discipline according to user request.

2476

* Set the line discipline according to user request.

2477

*

2477

*

2478

* Locking: see tty_set_ldisc, this function is just a helper

2478

* Locking: see tty_set_ldisc, this function is just a helper

2479

*/

2479

*/

2480

2481

static int tiocsetd(struct tty_struct *tty, int __user *p)

2481

static int tiocsetd(struct tty_struct *tty, int __user *p)

2482

{

2482

{

2483

int ldisc;

2483

int ldisc;

2484

int ret;

2484

int ret;

2485

2486

if (get_user(ldisc, p))

2486

if (get_user(ldisc, p))

2487

return -EFAULT;

2487

return -EFAULT;

2488

2489

ret = tty_set_ldisc(tty, ldisc);

2489

ret = tty_set_ldisc(tty, ldisc);

2490

2491

return ret;

2491

return ret;

2492

}

2492

}

2493

2494

/**

2494

/**

2495

* send_break - performed time break

2495

* send_break - performed time break

2496

* @tty: device to break on

2496

* @tty: device to break on

2497

* @duration: timeout in mS

2497

* @duration: timeout in mS

2498

*

2498

*

2499

* Perform a timed break on hardware that lacks its own driver level

2499

* Perform a timed break on hardware that lacks its own driver level

2500

* timed break functionality.

2500

* timed break functionality.

2501

*

2501

*

2502

* Locking:

2502

* Locking:

2503

* atomic_write_lock serializes

2503

* atomic_write_lock serializes

2504

*

2504

*

2505

*/

2505

*/

2506

2507

static int send_break(struct tty_struct *tty, unsigned int duration)

2507

static int send_break(struct tty_struct *tty, unsigned int duration)

2508

{

2508

{

2509

int retval;

2509

int retval;

2510

2511

if (tty->ops->break_ctl == NULL)

2511

if (tty->ops->break_ctl == NULL)

2512

return 0;

2512

return 0;

2513

2514

if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)

2514

if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)

2515

retval = tty->ops->break_ctl(tty, duration);

2515

retval = tty->ops->break_ctl(tty, duration);

2516

else {

2516

else {

2517

/* Do the work ourselves */

2517

/* Do the work ourselves */

2518

if (tty_write_lock(tty, 0) < 0)

2518

if (tty_write_lock(tty, 0) < 0)

2519

return -EINTR;

2519

return -EINTR;

2520

retval = tty->ops->break_ctl(tty, -1);

2520

retval = tty->ops->break_ctl(tty, -1);

2521

if (retval)

2521

if (retval)

2522

goto out;

2522

goto out;

2523

if (!signal_pending(current))

2523

if (!signal_pending(current))

2524

msleep_interruptible(duration);

2524

msleep_interruptible(duration);

2525

retval = tty->ops->break_ctl(tty, 0);

2525

retval = tty->ops->break_ctl(tty, 0);

2526

out:

2526

out:

2527

tty_write_unlock(tty);

2527

tty_write_unlock(tty);

2528

if (signal_pending(current))

2528

if (signal_pending(current))

2529

retval = -EINTR;

2529

retval = -EINTR;

2530

}

2530

}

2531

return retval;

2531

return retval;

2532

}

2532

}

2533

2534

/**

2534

/**

2535

* tty_tiocmget - get modem status

2535

* tty_tiocmget - get modem status

2536

* @tty: tty device

2536

* @tty: tty device

2537

* @file: user file pointer

2537

* @file: user file pointer

2538

* @p: pointer to result

2538

* @p: pointer to result

2539

*

2539

*

2540

* Obtain the modem status bits from the tty driver if the feature

2540

* Obtain the modem status bits from the tty driver if the feature

2541

* is supported. Return -EINVAL if it is not available.

2541

* is supported. Return -EINVAL if it is not available.

2542

*

2542

*

2543

* Locking: none (up to the driver)

2543

* Locking: none (up to the driver)

2544

*/

2544

*/

2545

2546

static int tty_tiocmget(struct tty_struct *tty, int __user *p)

2546

static int tty_tiocmget(struct tty_struct *tty, int __user *p)

2547

{

2547

{

2548

int retval = -EINVAL;

2548

int retval = -EINVAL;

2549

2550

if (tty->ops->tiocmget) {

2550

if (tty->ops->tiocmget) {

2551

retval = tty->ops->tiocmget(tty);

2551

retval = tty->ops->tiocmget(tty);

2552

2553

if (retval >= 0)

2553

if (retval >= 0)

2554

retval = put_user(retval, p);

2554

retval = put_user(retval, p);

2555

}

2555

}

2556

return retval;

2556

return retval;

2557

}

2557

}

2558

2559

/**

2559

/**

2560

* tty_tiocmset - set modem status

2560

* tty_tiocmset - set modem status

2561

* @tty: tty device

2561

* @tty: tty device

2562

* @cmd: command - clear bits, set bits or set all

2562

* @cmd: command - clear bits, set bits or set all

2563

* @p: pointer to desired bits

2563

* @p: pointer to desired bits

2564

*

2564

*

2565

* Set the modem status bits from the tty driver if the feature

2565

* Set the modem status bits from the tty driver if the feature

2566

* is supported. Return -EINVAL if it is not available.

2566

* is supported. Return -EINVAL if it is not available.

2567

*

2567

*

2568

* Locking: none (up to the driver)

2568

* Locking: none (up to the driver)

2569

*/

2569

*/

2570

2571

static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,

2571

static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,

2572

unsigned __user *p)

2572

unsigned __user *p)

2573

{

2573

{

2574

int retval;

2574

int retval;

2575

unsigned int set, clear, val;

2575

unsigned int set, clear, val;

2576

2577

if (tty->ops->tiocmset == NULL)

2577

if (tty->ops->tiocmset == NULL)

2578

return -EINVAL;

2578

return -EINVAL;

2579

2580

retval = get_user(val, p);

2580

retval = get_user(val, p);

2581

if (retval)

2581

if (retval)

2582

return retval;

2582

return retval;

2583

set = clear = 0;

2583

set = clear = 0;

2584

switch (cmd) {

2584

switch (cmd) {

2585

case TIOCMBIS:

2585

case TIOCMBIS:

2586

set = val;

2586

set = val;

2587

break;

2587

break;

2588

case TIOCMBIC:

2588

case TIOCMBIC:

2589

clear = val;

2589

clear = val;

2590

break;

2590

break;

2591

case TIOCMSET:

2591

case TIOCMSET:

2592

set = val;

2592

set = val;

2593

clear = ~val;

2593

clear = ~val;

2594

break;

2594

break;

2595

}

2595

}

2596

set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;

2596

set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;

2597

clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;

2597

clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;

2598

return tty->ops->tiocmset(tty, set, clear);

2598

return tty->ops->tiocmset(tty, set, clear);

2599

}

2599

}

2600

2601

static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)

2601

static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)

2602

{

2602

{

2603

int retval = -EINVAL;

2603

int retval = -EINVAL;

2604

struct serial_icounter_struct icount;

2604

struct serial_icounter_struct icount;

2605

memset(&icount, 0, sizeof(icount));

2605

memset(&icount, 0, sizeof(icount));

2606

if (tty->ops->get_icount)

2606

if (tty->ops->get_icount)

2607

retval = tty->ops->get_icount(tty, &icount);

2607

retval = tty->ops->get_icount(tty, &icount);

2608

if (retval != 0)

2608

if (retval != 0)

2609

return retval;

2609

return retval;

2610

if (copy_to_user(arg, &icount, sizeof(icount)))

2610

if (copy_to_user(arg, &icount, sizeof(icount)))

2611

return -EFAULT;

2611

return -EFAULT;

2612

return 0;

2612

return 0;

2613

}

2613

}

2614

2615

struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)

2615

struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)

2616

{

2616

{

2617

if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&

2617

if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&

2618

tty->driver->subtype == PTY_TYPE_MASTER)

2618

tty->driver->subtype == PTY_TYPE_MASTER)

2619

tty = tty->link;

2619

tty = tty->link;

2620

return tty;

2620

return tty;

2621

}

2621

}

2622

EXPORT_SYMBOL(tty_pair_get_tty);

2622

EXPORT_SYMBOL(tty_pair_get_tty);

2623

2624

struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)

2624

struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)

2625

{

2625

{

2626

if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&

2626

if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&

2627

tty->driver->subtype == PTY_TYPE_MASTER)

2627

tty->driver->subtype == PTY_TYPE_MASTER)

2628

return tty;

2628

return tty;

2629

return tty->link;

2629

return tty->link;

2630

}

2630

}

2631

EXPORT_SYMBOL(tty_pair_get_pty);

2631

EXPORT_SYMBOL(tty_pair_get_pty);

2632

2633

/*

2633

/*

2634

* Split this up, as gcc can choke on it otherwise..

2634

* Split this up, as gcc can choke on it otherwise..

2635

*/

2635

*/

2636

long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

2636

long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)

2637

{

2637

{

2638

struct tty_struct *tty = file_tty(file);

2638

struct tty_struct *tty = file_tty(file);

2639

struct tty_struct *real_tty;

2639

struct tty_struct *real_tty;

2640

void __user *p = (void __user *)arg;

2640

void __user *p = (void __user *)arg;

2641

int retval;

2641

int retval;

2642

struct tty_ldisc *ld;

2642

struct tty_ldisc *ld;

2643

struct inode *inode = file->f_dentry->d_inode;

2643

struct inode *inode = file->f_dentry->d_inode;

2644

2645

if (tty_paranoia_check(tty, inode, "tty_ioctl"))

2645

if (tty_paranoia_check(tty, inode, "tty_ioctl"))

2646

return -EINVAL;

2646

return -EINVAL;

2647

2648

real_tty = tty_pair_get_tty(tty);

2648

real_tty = tty_pair_get_tty(tty);

2649

2650

/*

2650

/*

2651

* Factor out some common prep work

2651

* Factor out some common prep work

2652

*/

2652

*/

2653

switch (cmd) {

2653

switch (cmd) {

2654

case TIOCSETD:

2654

case TIOCSETD:

2655

case TIOCSBRK:

2655

case TIOCSBRK:

2656

case TIOCCBRK:

2656

case TIOCCBRK:

2657

case TCSBRK:

2657

case TCSBRK:

2658

case TCSBRKP:

2658

case TCSBRKP:

2659

retval = tty_check_change(tty);

2659

retval = tty_check_change(tty);

2660

if (retval)

2660

if (retval)

2661

return retval;

2661

return retval;

2662

if (cmd != TIOCCBRK) {

2662

if (cmd != TIOCCBRK) {

2663

tty_wait_until_sent(tty, 0);

2663

tty_wait_until_sent(tty, 0);

2664

if (signal_pending(current))

2664

if (signal_pending(current))

2665

return -EINTR;

2665

return -EINTR;

2666

}

2666

}

2667

break;

2667

break;

2668

}

2668

}

2669

2670

/*

2670

/*

2671

* Now do the stuff.

2671

* Now do the stuff.

2672

*/

2672

*/

2673

switch (cmd) {

2673

switch (cmd) {

2674

case TIOCSTI:

2674

case TIOCSTI:

2675

return tiocsti(tty, p);

2675

return tiocsti(tty, p);

2676

case TIOCGWINSZ:

2676

case TIOCGWINSZ:

2677

return tiocgwinsz(real_tty, p);

2677

return tiocgwinsz(real_tty, p);

2678

case TIOCSWINSZ:

2678

case TIOCSWINSZ:

2679

return tiocswinsz(real_tty, p);

2679

return tiocswinsz(real_tty, p);

2680

case TIOCCONS:

2680

case TIOCCONS:

2681

return real_tty != tty ? -EINVAL : tioccons(file);

2681

return real_tty != tty ? -EINVAL : tioccons(file);

2682

case FIONBIO:

2682

case FIONBIO:

2683

return fionbio(file, p);

2683

return fionbio(file, p);

2684

case TIOCEXCL:

2684

case TIOCEXCL:

2685

set_bit(TTY_EXCLUSIVE, &tty->flags);

2685

set_bit(TTY_EXCLUSIVE, &tty->flags);

2686

return 0;

2686

return 0;

2687

case TIOCNXCL:

2687

case TIOCNXCL:

2688

clear_bit(TTY_EXCLUSIVE, &tty->flags);

2688

clear_bit(TTY_EXCLUSIVE, &tty->flags);

2689

return 0;

2689

return 0;

2690

case TIOCGEXCL:

2691

{

2692

int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);

2693

return put_user(excl, (int __user *)p);

2694

}

2690

case TIOCNOTTY:

2695

case TIOCNOTTY:

2691

if (current->signal->tty != tty)

2696

if (current->signal->tty != tty)

2692

return -ENOTTY;

2697

return -ENOTTY;

2693

no_tty();

2698

no_tty();

2694

return 0;

2699

return 0;

2695

case TIOCSCTTY:

2700

case TIOCSCTTY:

2696

return tiocsctty(tty, arg);

2701

return tiocsctty(tty, arg);

2697

case TIOCGPGRP:

2702

case TIOCGPGRP:

2698

return tiocgpgrp(tty, real_tty, p);

2703

return tiocgpgrp(tty, real_tty, p);

2699

case TIOCSPGRP:

2704

case TIOCSPGRP:

2700

return tiocspgrp(tty, real_tty, p);

2705

return tiocspgrp(tty, real_tty, p);

2701

case TIOCGSID:

2706

case TIOCGSID:

2702

return tiocgsid(tty, real_tty, p);

2707

return tiocgsid(tty, real_tty, p);

2703

case TIOCGETD:

2708

case TIOCGETD:

2704

return put_user(tty->ldisc->ops->num, (int __user *)p);

2709

return put_user(tty->ldisc->ops->num, (int __user *)p);

2705

case TIOCSETD:

2710

case TIOCSETD:

2706

return tiocsetd(tty, p);

2711

return tiocsetd(tty, p);

2707

case TIOCVHANGUP:

2712

case TIOCVHANGUP:

2708

if (!capable(CAP_SYS_ADMIN))

2713

if (!capable(CAP_SYS_ADMIN))

2709

return -EPERM;

2714

return -EPERM;

2710

tty_vhangup(tty);

2715

tty_vhangup(tty);

2711

return 0;

2716

return 0;

2712

case TIOCGDEV:

2717

case TIOCGDEV:

2713

{

2718

{

2714

unsigned int ret = new_encode_dev(tty_devnum(real_tty));

2719

unsigned int ret = new_encode_dev(tty_devnum(real_tty));

2715

return put_user(ret, (unsigned int __user *)p);

2720

return put_user(ret, (unsigned int __user *)p);

2716

}

2721

}

2717

/*

2722

/*

2718

* Break handling

2723

* Break handling

2719

*/

2724

*/

2720

case TIOCSBRK: /* Turn break on, unconditionally */

2725

case TIOCSBRK: /* Turn break on, unconditionally */

2721

if (tty->ops->break_ctl)

2726

if (tty->ops->break_ctl)

2722

return tty->ops->break_ctl(tty, -1);

2727

return tty->ops->break_ctl(tty, -1);

2723

return 0;

2728

return 0;

2724

case TIOCCBRK: /* Turn break off, unconditionally */

2729

case TIOCCBRK: /* Turn break off, unconditionally */

2725

if (tty->ops->break_ctl)

2730

if (tty->ops->break_ctl)

2726

return tty->ops->break_ctl(tty, 0);

2731

return tty->ops->break_ctl(tty, 0);

2727

return 0;

2732

return 0;

2728

case TCSBRK: /* SVID version: non-zero arg --> no break */

2733

case TCSBRK: /* SVID version: non-zero arg --> no break */

2729

/* non-zero arg means wait for all output data

2734

/* non-zero arg means wait for all output data

2730

* to be sent (performed above) but don't send break.

2735

* to be sent (performed above) but don't send break.

2731

* This is used by the tcdrain() termios function.

2736

* This is used by the tcdrain() termios function.

2732

*/

2737

*/

2733

if (!arg)

2738

if (!arg)

2734

return send_break(tty, 250);

2739

return send_break(tty, 250);

2735

return 0;

2740

return 0;

2736

case TCSBRKP: /* support for POSIX tcsendbreak() */

2741

case TCSBRKP: /* support for POSIX tcsendbreak() */

2737

return send_break(tty, arg ? arg*100 : 250);

2742

return send_break(tty, arg ? arg*100 : 250);

2738

2743

2739

case TIOCMGET:

2744

case TIOCMGET:

2740

return tty_tiocmget(tty, p);

2745

return tty_tiocmget(tty, p);

2741

case TIOCMSET:

2746

case TIOCMSET:

2742

case TIOCMBIC:

2747

case TIOCMBIC:

2743

case TIOCMBIS:

2748

case TIOCMBIS:

2744

return tty_tiocmset(tty, cmd, p);

2749

return tty_tiocmset(tty, cmd, p);

2745

case TIOCGICOUNT:

2750

case TIOCGICOUNT:

2746

retval = tty_tiocgicount(tty, p);

2751

retval = tty_tiocgicount(tty, p);

2747

/* For the moment allow fall through to the old method */

2752

/* For the moment allow fall through to the old method */

2748

if (retval != -EINVAL)

2753

if (retval != -EINVAL)

2749

return retval;

2754

return retval;

2750

break;

2755

break;

2751

case TCFLSH:

2756

case TCFLSH:

2752

switch (arg) {

2757

switch (arg) {

2753

case TCIFLUSH:

2758

case TCIFLUSH:

2754

case TCIOFLUSH:

2759

case TCIOFLUSH:

2755

/* flush tty buffer and allow ldisc to process ioctl */

2760

/* flush tty buffer and allow ldisc to process ioctl */

2756

tty_buffer_flush(tty);

2761

tty_buffer_flush(tty);

2757

break;

2762

break;

2758

}

2763

}

2759

break;

2764

break;

2760

}

2765

}

2761

if (tty->ops->ioctl) {

2766

if (tty->ops->ioctl) {

2762

retval = (tty->ops->ioctl)(tty, cmd, arg);

2767

retval = (tty->ops->ioctl)(tty, cmd, arg);

2763

if (retval != -ENOIOCTLCMD)

2768

if (retval != -ENOIOCTLCMD)

2764

return retval;

2769

return retval;

2765

}

2770

}

2766

ld = tty_ldisc_ref_wait(tty);

2771

ld = tty_ldisc_ref_wait(tty);

2767

retval = -EINVAL;

2772

retval = -EINVAL;

2768

if (ld->ops->ioctl) {

2773

if (ld->ops->ioctl) {

2769

retval = ld->ops->ioctl(tty, file, cmd, arg);

2774

retval = ld->ops->ioctl(tty, file, cmd, arg);

2770

if (retval == -ENOIOCTLCMD)

2775

if (retval == -ENOIOCTLCMD)

2771

retval = -ENOTTY;

2776

retval = -ENOTTY;

2772

}

2777

}

2773

tty_ldisc_deref(ld);

2778

tty_ldisc_deref(ld);

2774

return retval;

2779

return retval;

2775

}

2780

}

2776

2781

2777

#ifdef CONFIG_COMPAT

2782

#ifdef CONFIG_COMPAT

2778

static long tty_compat_ioctl(struct file *file, unsigned int cmd,

2783

static long tty_compat_ioctl(struct file *file, unsigned int cmd,

2779

unsigned long arg)

2784

unsigned long arg)

2780

{

2785

{

2781

struct inode *inode = file->f_dentry->d_inode;

2786

struct inode *inode = file->f_dentry->d_inode;

2782

struct tty_struct *tty = file_tty(file);

2787

struct tty_struct *tty = file_tty(file);

2783

struct tty_ldisc *ld;

2788

struct tty_ldisc *ld;

2784

int retval = -ENOIOCTLCMD;

2789

int retval = -ENOIOCTLCMD;

2785

2790

2786

if (tty_paranoia_check(tty, inode, "tty_ioctl"))

2791

if (tty_paranoia_check(tty, inode, "tty_ioctl"))

2787

return -EINVAL;

2792

return -EINVAL;

2788

2793

2789

if (tty->ops->compat_ioctl) {

2794

if (tty->ops->compat_ioctl) {

2790

retval = (tty->ops->compat_ioctl)(tty, cmd, arg);

2795

retval = (tty->ops->compat_ioctl)(tty, cmd, arg);

2791

if (retval != -ENOIOCTLCMD)

2796

if (retval != -ENOIOCTLCMD)

2792

return retval;

2797

return retval;

2793

}

2798

}

2794

2799

2795

ld = tty_ldisc_ref_wait(tty);

2800

ld = tty_ldisc_ref_wait(tty);

2796

if (ld->ops->compat_ioctl)

2801

if (ld->ops->compat_ioctl)

2797

retval = ld->ops->compat_ioctl(tty, file, cmd, arg);

2802

retval = ld->ops->compat_ioctl(tty, file, cmd, arg);

2798

else

2803

else

2799

retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);

2804

retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);

2800

tty_ldisc_deref(ld);

2805

tty_ldisc_deref(ld);

2801

2806

2802

return retval;

2807

return retval;

2803

}

2808

}

2804

#endif

2809

#endif

2805

2810

2806

static int this_tty(const void *t, struct file *file, unsigned fd)

2811

static int this_tty(const void *t, struct file *file, unsigned fd)

2807

{

2812

{

2808

if (likely(file->f_op->read != tty_read))

2813

if (likely(file->f_op->read != tty_read))

2809

return 0;

2814

return 0;

2810

return file_tty(file) != t ? 0 : fd + 1;

2815

return file_tty(file) != t ? 0 : fd + 1;

2811

}

2816

}

2812

2817

2813

/*

2818

/*

2814

* This implements the "Secure Attention Key" --- the idea is to

2819

* This implements the "Secure Attention Key" --- the idea is to

2815

* prevent trojan horses by killing all processes associated with this

2820

* prevent trojan horses by killing all processes associated with this

2816

* tty when the user hits the "Secure Attention Key". Required for

2821

* tty when the user hits the "Secure Attention Key". Required for

2817

* super-paranoid applications --- see the Orange Book for more details.

2822

* super-paranoid applications --- see the Orange Book for more details.

2818

*

2823

*

2819

* This code could be nicer; ideally it should send a HUP, wait a few

2824

* This code could be nicer; ideally it should send a HUP, wait a few

2820

* seconds, then send a INT, and then a KILL signal. But you then

2825

* seconds, then send a INT, and then a KILL signal. But you then

2821

* have to coordinate with the init process, since all processes associated

2826

* have to coordinate with the init process, since all processes associated

2822

* with the current tty must be dead before the new getty is allowed

2827

* with the current tty must be dead before the new getty is allowed

2823

* to spawn.

2828

* to spawn.

2824

*

2829

*

2825

* Now, if it would be correct ;-/ The current code has a nasty hole -

2830

* Now, if it would be correct ;-/ The current code has a nasty hole -

2826

* it doesn't catch files in flight. We may send the descriptor to ourselves

2831

* it doesn't catch files in flight. We may send the descriptor to ourselves

2827

* via AF_UNIX socket, close it and later fetch from socket. FIXME.

2832

* via AF_UNIX socket, close it and later fetch from socket. FIXME.

2828

*

2833

*

2829

* Nasty bug: do_SAK is being called in interrupt context. This can

2834

* Nasty bug: do_SAK is being called in interrupt context. This can

2830

* deadlock. We punt it up to process context. AKPM - 16Mar2001

2835

* deadlock. We punt it up to process context. AKPM - 16Mar2001

2831

*/

2836

*/

2832

void __do_SAK(struct tty_struct *tty)

2837

void __do_SAK(struct tty_struct *tty)

2833

{

2838

{

2834

#ifdef TTY_SOFT_SAK

2839

#ifdef TTY_SOFT_SAK

2835

tty_hangup(tty);

2840

tty_hangup(tty);

2836

#else

2841

#else

2837

struct task_struct *g, *p;

2842

struct task_struct *g, *p;

2838

struct pid *session;

2843

struct pid *session;

2839

int i;

2844

int i;

2840

2845

2841

if (!tty)

2846

if (!tty)

2842

return;

2847

return;

2843

session = tty->session;

2848

session = tty->session;

2844

2849

2845

tty_ldisc_flush(tty);

2850

tty_ldisc_flush(tty);

2846

2851

2847

tty_driver_flush_buffer(tty);

2852

tty_driver_flush_buffer(tty);

2848

2853

2849

read_lock(&tasklist_lock);

2854

read_lock(&tasklist_lock);

2850

/* Kill the entire session */

2855

/* Kill the entire session */

2851

do_each_pid_task(session, PIDTYPE_SID, p) {

2856

do_each_pid_task(session, PIDTYPE_SID, p) {

2852

printk(KERN_NOTICE "SAK: killed process %d"

2857

printk(KERN_NOTICE "SAK: killed process %d"

2853

" (%s): task_session(p)==tty->session\n",

2858

" (%s): task_session(p)==tty->session\n",

2854

task_pid_nr(p), p->comm);

2859

task_pid_nr(p), p->comm);

2855

send_sig(SIGKILL, p, 1);

2860

send_sig(SIGKILL, p, 1);

2856

} while_each_pid_task(session, PIDTYPE_SID, p);

2861

} while_each_pid_task(session, PIDTYPE_SID, p);

2857

/* Now kill any processes that happen to have the

2862

/* Now kill any processes that happen to have the

2858

* tty open.

2863

* tty open.

2859

*/

2864

*/

2860

do_each_thread(g, p) {

2865

do_each_thread(g, p) {

2861

if (p->signal->tty == tty) {

2866

if (p->signal->tty == tty) {

2862

printk(KERN_NOTICE "SAK: killed process %d"

2867

printk(KERN_NOTICE "SAK: killed process %d"

2863

" (%s): task_session(p)==tty->session\n",

2868

" (%s): task_session(p)==tty->session\n",

2864

task_pid_nr(p), p->comm);

2869

task_pid_nr(p), p->comm);

2865

send_sig(SIGKILL, p, 1);

2870

send_sig(SIGKILL, p, 1);

2866

continue;

2871

continue;

2867

}

2872

}

2868

task_lock(p);

2873

task_lock(p);

2869

i = iterate_fd(p->files, 0, this_tty, tty);

2874

i = iterate_fd(p->files, 0, this_tty, tty);

2870

if (i != 0) {

2875

if (i != 0) {

2871

printk(KERN_NOTICE "SAK: killed process %d"

2876

printk(KERN_NOTICE "SAK: killed process %d"

2872

" (%s): fd#%d opened to the tty\n",

2877

" (%s): fd#%d opened to the tty\n",

2873

task_pid_nr(p), p->comm, i - 1);

2878

task_pid_nr(p), p->comm, i - 1);

2874

force_sig(SIGKILL, p);

2879

force_sig(SIGKILL, p);

2875

}

2880

}

2876

task_unlock(p);

2881

task_unlock(p);

2877

} while_each_thread(g, p);

2882

} while_each_thread(g, p);

2878

read_unlock(&tasklist_lock);

2883

read_unlock(&tasklist_lock);

2879

#endif

2884

#endif

2880

}

2885

}

2881

2886

2882

static void do_SAK_work(struct work_struct *work)

2887

static void do_SAK_work(struct work_struct *work)

2883

{

2888

{

2884

struct tty_struct *tty =

2889

struct tty_struct *tty =

2885

container_of(work, struct tty_struct, SAK_work);

2890

container_of(work, struct tty_struct, SAK_work);

2886

__do_SAK(tty);

2891

__do_SAK(tty);

2887

}

2892

}

2888

2893

2889

/*

2894

/*

2890

* The tq handling here is a little racy - tty->SAK_work may already be queued.

2895

* The tq handling here is a little racy - tty->SAK_work may already be queued.

2891

* Fortunately we don't need to worry, because if ->SAK_work is already queued,

2896

* Fortunately we don't need to worry, because if ->SAK_work is already queued,

2892

* the values which we write to it will be identical to the values which it

2897

* the values which we write to it will be identical to the values which it

2893

* already has. --akpm

2898

* already has. --akpm

2894

*/

2899

*/

2895

void do_SAK(struct tty_struct *tty)

2900

void do_SAK(struct tty_struct *tty)

2896

{

2901

{

2897

if (!tty)

2902

if (!tty)

2898

return;

2903

return;

2899

schedule_work(&tty->SAK_work);

2904

schedule_work(&tty->SAK_work);

2900

}

2905

}

2901

2906

2902

EXPORT_SYMBOL(do_SAK);

2907

EXPORT_SYMBOL(do_SAK);

2903

2908

2904

static int dev_match_devt(struct device *dev, void *data)

2909

static int dev_match_devt(struct device *dev, void *data)

2905

{

2910

{

2906

dev_t *devt = data;

2911

dev_t *devt = data;

2907

return dev->devt == *devt;

2912

return dev->devt == *devt;

2908

}

2913

}

2909

2914

2910

/* Must put_device() after it's unused! */

2915

/* Must put_device() after it's unused! */

2911

static struct device *tty_get_device(struct tty_struct *tty)

2916

static struct device *tty_get_device(struct tty_struct *tty)

2912

{

2917

{

2913

dev_t devt = tty_devnum(tty);

2918

dev_t devt = tty_devnum(tty);

2914

return class_find_device(tty_class, NULL, &devt, dev_match_devt);

2919

return class_find_device(tty_class, NULL, &devt, dev_match_devt);

2915

}

2920

}

2916

2921

2917

2922

2918

/**

2923

/**

2919

* initialize_tty_struct

2924

* initialize_tty_struct

2920

* @tty: tty to initialize

2925

* @tty: tty to initialize

2921

*

2926

*

2922

* This subroutine initializes a tty structure that has been newly

2927

* This subroutine initializes a tty structure that has been newly

2923

* allocated.

2928

* allocated.

2924

*

2929

*

2925

* Locking: none - tty in question must not be exposed at this point

2930

* Locking: none - tty in question must not be exposed at this point

2926

*/

2931

*/

2927

2932

2928

void initialize_tty_struct(struct tty_struct *tty,

2933

void initialize_tty_struct(struct tty_struct *tty,

2929

struct tty_driver *driver, int idx)

2934

struct tty_driver *driver, int idx)

2930

{

2935

{

2931

memset(tty, 0, sizeof(struct tty_struct));

2936

memset(tty, 0, sizeof(struct tty_struct));

2932

kref_init(&tty->kref);

2937

kref_init(&tty->kref);

2933

tty->magic = TTY_MAGIC;

2938

tty->magic = TTY_MAGIC;

2934

tty_ldisc_init(tty);

2939

tty_ldisc_init(tty);

2935

tty->session = NULL;

2940

tty->session = NULL;

2936

tty->pgrp = NULL;

2941

tty->pgrp = NULL;

2937

mutex_init(&tty->legacy_mutex);

2942

mutex_init(&tty->legacy_mutex);

2938

mutex_init(&tty->termios_mutex);

2943

mutex_init(&tty->termios_mutex);

2939

mutex_init(&tty->ldisc_mutex);

2944

mutex_init(&tty->ldisc_mutex);

2940

init_waitqueue_head(&tty->write_wait);

2945

init_waitqueue_head(&tty->write_wait);

2941

init_waitqueue_head(&tty->read_wait);

2946

init_waitqueue_head(&tty->read_wait);

2942

INIT_WORK(&tty->hangup_work, do_tty_hangup);

2947

INIT_WORK(&tty->hangup_work, do_tty_hangup);

2943

mutex_init(&tty->atomic_write_lock);

2948

mutex_init(&tty->atomic_write_lock);

2944

spin_lock_init(&tty->ctrl_lock);

2949

spin_lock_init(&tty->ctrl_lock);

2945

INIT_LIST_HEAD(&tty->tty_files);

2950

INIT_LIST_HEAD(&tty->tty_files);

2946

INIT_WORK(&tty->SAK_work, do_SAK_work);

2951

INIT_WORK(&tty->SAK_work, do_SAK_work);

2947

2952

2948

tty->driver = driver;

2953

tty->driver = driver;

2949

tty->ops = driver->ops;

2954

tty->ops = driver->ops;

2950

tty->index = idx;

2955

tty->index = idx;

2951

tty_line_name(driver, idx, tty->name);

2956

tty_line_name(driver, idx, tty->name);

2952

tty->dev = tty_get_device(tty);

2957

tty->dev = tty_get_device(tty);

2953

}

2958

}

2954

2959

2955

/**

2960

/**

2956

* deinitialize_tty_struct

2961

* deinitialize_tty_struct

2957

* @tty: tty to deinitialize

2962

* @tty: tty to deinitialize

2958

*

2963

*

2959

* This subroutine deinitializes a tty structure that has been newly

2964

* This subroutine deinitializes a tty structure that has been newly

2960

* allocated but tty_release cannot be called on that yet.

2965

* allocated but tty_release cannot be called on that yet.

2961

*

2966

*

2962

* Locking: none - tty in question must not be exposed at this point

2967

* Locking: none - tty in question must not be exposed at this point

2963

*/

2968

*/

2964

void deinitialize_tty_struct(struct tty_struct *tty)

2969

void deinitialize_tty_struct(struct tty_struct *tty)

2965

{

2970

{

2966

tty_ldisc_deinit(tty);

2971

tty_ldisc_deinit(tty);

2967

}

2972

}

2968

2973

2969

/**

2974

/**

2970

* tty_put_char - write one character to a tty

2975

* tty_put_char - write one character to a tty

2971

* @tty: tty

2976

* @tty: tty

2972

* @ch: character

2977

* @ch: character

2973

*

2978

*

2974

* Write one byte to the tty using the provided put_char method

2979

* Write one byte to the tty using the provided put_char method

2975

* if present. Returns the number of characters successfully output.

2980

* if present. Returns the number of characters successfully output.

2976

*

2981

*

2977

* Note: the specific put_char operation in the driver layer may go

2982

* Note: the specific put_char operation in the driver layer may go

2978

* away soon. Don't call it directly, use this method

2983

* away soon. Don't call it directly, use this method

2979

*/

2984

*/

2980

2985

2981

int tty_put_char(struct tty_struct *tty, unsigned char ch)

2986

int tty_put_char(struct tty_struct *tty, unsigned char ch)

2982

{

2987

{

2983

if (tty->ops->put_char)

2988

if (tty->ops->put_char)

2984

return tty->ops->put_char(tty, ch);

2989

return tty->ops->put_char(tty, ch);

2985

return tty->ops->write(tty, &ch, 1);

2990

return tty->ops->write(tty, &ch, 1);

2986

}

2991

}

2987

EXPORT_SYMBOL_GPL(tty_put_char);

2992

EXPORT_SYMBOL_GPL(tty_put_char);

2988

2993

2989

struct class *tty_class;

2994

struct class *tty_class;

2990

2995

2991

static int tty_cdev_add(struct tty_driver *driver, dev_t dev,

2996

static int tty_cdev_add(struct tty_driver *driver, dev_t dev,

2992

unsigned int index, unsigned int count)

2997

unsigned int index, unsigned int count)

2993

{

2998

{

2994

/* init here, since reused cdevs cause crashes */

2999

/* init here, since reused cdevs cause crashes */

2995

cdev_init(&driver->cdevs[index], &tty_fops);

3000

cdev_init(&driver->cdevs[index], &tty_fops);

2996

driver->cdevs[index].owner = driver->owner;

3001

driver->cdevs[index].owner = driver->owner;

2997

return cdev_add(&driver->cdevs[index], dev, count);

3002

return cdev_add(&driver->cdevs[index], dev, count);

2998

}

3003

}

2999

3004

3000

/**

3005

/**

3001

* tty_register_device - register a tty device

3006

* tty_register_device - register a tty device

3002

* @driver: the tty driver that describes the tty device

3007

* @driver: the tty driver that describes the tty device

3003

* @index: the index in the tty driver for this tty device

3008

* @index: the index in the tty driver for this tty device

3004

* @device: a struct device that is associated with this tty device.

3009

* @device: a struct device that is associated with this tty device.

3005

* This field is optional, if there is no known struct device

3010

* This field is optional, if there is no known struct device

3006

* for this tty device it can be set to NULL safely.

3011

* for this tty device it can be set to NULL safely.

3007

*

3012

*

3008

* Returns a pointer to the struct device for this tty device

3013

* Returns a pointer to the struct device for this tty device

3009

* (or ERR_PTR(-EFOO) on error).

3014

* (or ERR_PTR(-EFOO) on error).

3010

*

3015

*

3011

* This call is required to be made to register an individual tty device

3016

* This call is required to be made to register an individual tty device

3012

* if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If

3017

* if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If

3013

* that bit is not set, this function should not be called by a tty

3018

* that bit is not set, this function should not be called by a tty

3014

* driver.

3019

* driver.

3015

*

3020

*

3016

* Locking: ??

3021

* Locking: ??

3017

*/

3022

*/

3018

3023

3019

struct device *tty_register_device(struct tty_driver *driver, unsigned index,

3024

struct device *tty_register_device(struct tty_driver *driver, unsigned index,

3020

struct device *device)

3025

struct device *device)

3021

{

3026

{

3022

return tty_register_device_attr(driver, index, device, NULL, NULL);

3027

return tty_register_device_attr(driver, index, device, NULL, NULL);

3023

}

3028

}

3024

EXPORT_SYMBOL(tty_register_device);

3029

EXPORT_SYMBOL(tty_register_device);

3025

3030

3026

static void tty_device_create_release(struct device *dev)

3031

static void tty_device_create_release(struct device *dev)

3027

{

3032

{

3028

pr_debug("device: '%s': %s\n", dev_name(dev), __func__);

3033

pr_debug("device: '%s': %s\n", dev_name(dev), __func__);

3029

kfree(dev);

3034

kfree(dev);

3030

}

3035

}

3031

3036

3032

/**

3037

/**

3033

* tty_register_device_attr - register a tty device

3038

* tty_register_device_attr - register a tty device

3034

* @driver: the tty driver that describes the tty device

3039

* @driver: the tty driver that describes the tty device

3035

* @index: the index in the tty driver for this tty device

3040

* @index: the index in the tty driver for this tty device

3036

* @device: a struct device that is associated with this tty device.

3041

* @device: a struct device that is associated with this tty device.

3037

* This field is optional, if there is no known struct device

3042

* This field is optional, if there is no known struct device

3038

* for this tty device it can be set to NULL safely.

3043

* for this tty device it can be set to NULL safely.

3039

* @drvdata: Driver data to be set to device.

3044

* @drvdata: Driver data to be set to device.

3040

* @attr_grp: Attribute group to be set on device.

3045

* @attr_grp: Attribute group to be set on device.

3041

*

3046

*

3042

* Returns a pointer to the struct device for this tty device

3047

* Returns a pointer to the struct device for this tty device

3043

* (or ERR_PTR(-EFOO) on error).

3048

* (or ERR_PTR(-EFOO) on error).

3044

*

3049

*

3045

* This call is required to be made to register an individual tty device

3050

* This call is required to be made to register an individual tty device

3046

* if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If

3051

* if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If

3047

* that bit is not set, this function should not be called by a tty

3052

* that bit is not set, this function should not be called by a tty

3048

* driver.

3053

* driver.

3049

*

3054

*

3050

* Locking: ??

3055

* Locking: ??

3051

*/

3056

*/

3052

struct device *tty_register_device_attr(struct tty_driver *driver,

3057

struct device *tty_register_device_attr(struct tty_driver *driver,

3053

unsigned index, struct device *device,

3058

unsigned index, struct device *device,

3054

void *drvdata,

3059

void *drvdata,

3055

const struct attribute_group **attr_grp)

3060

const struct attribute_group **attr_grp)

3056

{

3061

{

3057

char name[64];

3062

char name[64];

3058

dev_t devt = MKDEV(driver->major, driver->minor_start) + index;

3063

dev_t devt = MKDEV(driver->major, driver->minor_start) + index;

3059

struct device *dev = NULL;

3064

struct device *dev = NULL;

3060

int retval = -ENODEV;

3065

int retval = -ENODEV;

3061

bool cdev = false;

3066

bool cdev = false;

3062

3067

3063

if (index >= driver->num) {

3068

if (index >= driver->num) {

3064

printk(KERN_ERR "Attempt to register invalid tty line number "

3069

printk(KERN_ERR "Attempt to register invalid tty line number "

3065

" (%d).\n", index);

3070

" (%d).\n", index);

3066

return ERR_PTR(-EINVAL);

3071

return ERR_PTR(-EINVAL);

3067

}

3072

}

3068

3073

3069

if (driver->type == TTY_DRIVER_TYPE_PTY)

3074

if (driver->type == TTY_DRIVER_TYPE_PTY)

3070

pty_line_name(driver, index, name);

3075

pty_line_name(driver, index, name);

3071

else

3076

else

3072

tty_line_name(driver, index, name);

3077

tty_line_name(driver, index, name);

3073

3078

3074

if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {

3079

if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {

3075

retval = tty_cdev_add(driver, devt, index, 1);

3080

retval = tty_cdev_add(driver, devt, index, 1);

3076

if (retval)

3081

if (retval)

3077

goto error;

3082

goto error;

3078

cdev = true;

3083

cdev = true;

3079

}

3084

}

3080

3085

3081

dev = kzalloc(sizeof(*dev), GFP_KERNEL);

3086

dev = kzalloc(sizeof(*dev), GFP_KERNEL);

3082

if (!dev) {

3087

if (!dev) {

3083

retval = -ENOMEM;

3088

retval = -ENOMEM;

3084

goto error;

3089

goto error;

3085

}

3090

}

3086

3091

3087

dev->devt = devt;

3092

dev->devt = devt;

3088

dev->class = tty_class;

3093

dev->class = tty_class;

3089

dev->parent = device;

3094

dev->parent = device;

3090

dev->release = tty_device_create_release;

3095

dev->release = tty_device_create_release;

3091

dev_set_name(dev, "%s", name);

3096

dev_set_name(dev, "%s", name);

3092

dev->groups = attr_grp;

3097

dev->groups = attr_grp;

3093

dev_set_drvdata(dev, drvdata);

3098

dev_set_drvdata(dev, drvdata);

3094

3099

3095

retval = device_register(dev);

3100

retval = device_register(dev);

3096

if (retval)

3101

if (retval)

3097

goto error;

3102

goto error;

3098

3103

3099

return dev;

3104

return dev;

3100

3105

3101

error:

3106

error:

3102

put_device(dev);

3107

put_device(dev);

3103

if (cdev)

3108

if (cdev)

3104

cdev_del(&driver->cdevs[index]);

3109

cdev_del(&driver->cdevs[index]);

3105

return ERR_PTR(retval);

3110

return ERR_PTR(retval);

3106

}

3111

}

3107

EXPORT_SYMBOL_GPL(tty_register_device_attr);

3112

EXPORT_SYMBOL_GPL(tty_register_device_attr);

3108

3113

3109

/**

3114

/**

3110

* tty_unregister_device - unregister a tty device

3115

* tty_unregister_device - unregister a tty device

3111

* @driver: the tty driver that describes the tty device

3116

* @driver: the tty driver that describes the tty device

3112

* @index: the index in the tty driver for this tty device

3117

* @index: the index in the tty driver for this tty device

3113

*

3118

*

3114

* If a tty device is registered with a call to tty_register_device() then

3119

* If a tty device is registered with a call to tty_register_device() then

3115

* this function must be called when the tty device is gone.

3120

* this function must be called when the tty device is gone.

3116

*

3121

*

3117

* Locking: ??

3122

* Locking: ??

3118

*/

3123

*/

3119

3124

3120

void tty_unregister_device(struct tty_driver *driver, unsigned index)

3125

void tty_unregister_device(struct tty_driver *driver, unsigned index)

3121

{

3126

{

3122

device_destroy(tty_class,

3127

device_destroy(tty_class,

3123

MKDEV(driver->major, driver->minor_start) + index);

3128

MKDEV(driver->major, driver->minor_start) + index);

3124

if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))

3129

if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))

3125

cdev_del(&driver->cdevs[index]);

3130

cdev_del(&driver->cdevs[index]);

3126

}

3131

}

3127

EXPORT_SYMBOL(tty_unregister_device);

3132

EXPORT_SYMBOL(tty_unregister_device);

3128

3133

3129

/**

3134

/**

3130

* __tty_alloc_driver -- allocate tty driver

3135

* __tty_alloc_driver -- allocate tty driver

3131

* @lines: count of lines this driver can handle at most

3136

* @lines: count of lines this driver can handle at most

3132

* @owner: module which is repsonsible for this driver

3137

* @owner: module which is repsonsible for this driver

3133

* @flags: some of TTY_DRIVER_* flags, will be set in driver->flags

3138

* @flags: some of TTY_DRIVER_* flags, will be set in driver->flags

3134

*

3139

*

3135

* This should not be called directly, some of the provided macros should be

3140

* This should not be called directly, some of the provided macros should be

3136

* used instead. Use IS_ERR and friends on @retval.

3141

* used instead. Use IS_ERR and friends on @retval.

3137

*/

3142

*/

3138

struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,

3143

struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,

3139

unsigned long flags)

3144

unsigned long flags)

3140

{

3145

{

3141

struct tty_driver *driver;

3146

struct tty_driver *driver;

3142

unsigned int cdevs = 1;

3147

unsigned int cdevs = 1;

3143

int err;

3148

int err;

3144

3149

3145

if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))

3150

if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))

3146

return ERR_PTR(-EINVAL);

3151

return ERR_PTR(-EINVAL);

3147

3152

3148

driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);

3153

driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);

3149

if (!driver)

3154

if (!driver)

3150

return ERR_PTR(-ENOMEM);

3155

return ERR_PTR(-ENOMEM);

3151

3156

3152

kref_init(&driver->kref);

3157

kref_init(&driver->kref);

3153

driver->magic = TTY_DRIVER_MAGIC;

3158

driver->magic = TTY_DRIVER_MAGIC;

3154

driver->num = lines;

3159

driver->num = lines;

3155

driver->owner = owner;

3160

driver->owner = owner;

3156

driver->flags = flags;

3161

driver->flags = flags;

3157

3162

3158

if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {

3163

if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {

3159

driver->ttys = kcalloc(lines, sizeof(*driver->ttys),

3164

driver->ttys = kcalloc(lines, sizeof(*driver->ttys),

3160

GFP_KERNEL);

3165

GFP_KERNEL);

3161

driver->termios = kcalloc(lines, sizeof(*driver->termios),

3166

driver->termios = kcalloc(lines, sizeof(*driver->termios),

3162

GFP_KERNEL);

3167

GFP_KERNEL);

3163

if (!driver->ttys || !driver->termios) {

3168

if (!driver->ttys || !driver->termios) {

3164

err = -ENOMEM;

3169

err = -ENOMEM;

3165

goto err_free_all;

3170

goto err_free_all;

3166

}

3171

}

3167

}

3172

}

3168

3173

3169

if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {

3174

if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {

3170

driver->ports = kcalloc(lines, sizeof(*driver->ports),

3175

driver->ports = kcalloc(lines, sizeof(*driver->ports),

3171

GFP_KERNEL);

3176

GFP_KERNEL);

3172

if (!driver->ports) {

3177

if (!driver->ports) {

3173

err = -ENOMEM;

3178

err = -ENOMEM;

3174

goto err_free_all;

3179

goto err_free_all;

3175

}

3180

}

3176

cdevs = lines;

3181

cdevs = lines;

3177

}

3182

}

3178

3183

3179

driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);

3184

driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);

3180

if (!driver->cdevs) {

3185

if (!driver->cdevs) {

3181

err = -ENOMEM;

3186

err = -ENOMEM;

3182

goto err_free_all;

3187

goto err_free_all;

3183

}

3188

}

3184

3189

3185

return driver;

3190

return driver;

3186

err_free_all:

3191

err_free_all:

3187

kfree(driver->ports);

3192

kfree(driver->ports);

3188

kfree(driver->ttys);

3193

kfree(driver->ttys);

3189

kfree(driver->termios);

3194

kfree(driver->termios);

3190

kfree(driver);

3195

kfree(driver);

3191

return ERR_PTR(err);

3196

return ERR_PTR(err);

3192

}

3197

}

3193

EXPORT_SYMBOL(__tty_alloc_driver);

3198

EXPORT_SYMBOL(__tty_alloc_driver);

3194

3199

3195

static void destruct_tty_driver(struct kref *kref)

3200

static void destruct_tty_driver(struct kref *kref)

3196

{

3201

{

3197

struct tty_driver *driver = container_of(kref, struct tty_driver, kref);

3202

struct tty_driver *driver = container_of(kref, struct tty_driver, kref);

3198

int i;

3203

int i;

3199

struct ktermios *tp;

3204

struct ktermios *tp;

3200

3205

3201

if (driver->flags & TTY_DRIVER_INSTALLED) {

3206

if (driver->flags & TTY_DRIVER_INSTALLED) {

3202

/*

3207

/*

3203

* Free the termios and termios_locked structures because

3208

* Free the termios and termios_locked structures because

3204

* we don't want to get memory leaks when modular tty

3209

* we don't want to get memory leaks when modular tty

3205

* drivers are removed from the kernel.

3210

* drivers are removed from the kernel.

3206

*/

3211

*/

3207

for (i = 0; i < driver->num; i++) {

3212

for (i = 0; i < driver->num; i++) {

3208

tp = driver->termios[i];

3213

tp = driver->termios[i];

3209

if (tp) {

3214

if (tp) {

3210

driver->termios[i] = NULL;

3215

driver->termios[i] = NULL;

3211

kfree(tp);

3216

kfree(tp);

3212

}

3217

}

3213

if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))

3218

if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))

3214

tty_unregister_device(driver, i);

3219

tty_unregister_device(driver, i);

3215

}

3220

}

3216

proc_tty_unregister_driver(driver);

3221

proc_tty_unregister_driver(driver);

3217

if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)

3222

if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)

3218

cdev_del(&driver->cdevs[0]);

3223

cdev_del(&driver->cdevs[0]);

3219

}

3224

}

3220

kfree(driver->cdevs);

3225

kfree(driver->cdevs);

3221

kfree(driver->ports);

3226

kfree(driver->ports);

3222

kfree(driver->termios);

3227

kfree(driver->termios);

3223

kfree(driver->ttys);

3228

kfree(driver->ttys);

3224

kfree(driver);

3229

kfree(driver);

3225

}

3230

}

3226

3231

3227

void tty_driver_kref_put(struct tty_driver *driver)

3232

void tty_driver_kref_put(struct tty_driver *driver)

3228

{

3233

{

3229

kref_put(&driver->kref, destruct_tty_driver);

3234

kref_put(&driver->kref, destruct_tty_driver);

3230

}

3235

}

3231

EXPORT_SYMBOL(tty_driver_kref_put);

3236

EXPORT_SYMBOL(tty_driver_kref_put);

3232

3237

3233

void tty_set_operations(struct tty_driver *driver,

3238

void tty_set_operations(struct tty_driver *driver,

3234

const struct tty_operations *op)

3239

const struct tty_operations *op)

3235

{

3240

{

3236

driver->ops = op;

3241

driver->ops = op;

3237

};

3242

};

3238

EXPORT_SYMBOL(tty_set_operations);

3243

EXPORT_SYMBOL(tty_set_operations);

3239

3244

3240

void put_tty_driver(struct tty_driver *d)

3245

void put_tty_driver(struct tty_driver *d)

3241

{

3246

{

3242

tty_driver_kref_put(d);

3247

tty_driver_kref_put(d);

3243

}

3248

}

3244

EXPORT_SYMBOL(put_tty_driver);

3249

EXPORT_SYMBOL(put_tty_driver);

3245

3250

3246

/*

3251

/*

3247

* Called by a tty driver to register itself.

3252

* Called by a tty driver to register itself.

3248

*/

3253

*/

3249

int tty_register_driver(struct tty_driver *driver)

3254

int tty_register_driver(struct tty_driver *driver)

3250

{

3255

{

3251

int error;

3256

int error;

3252

int i;

3257

int i;

3253

dev_t dev;

3258

dev_t dev;

3254

struct device *d;

3259

struct device *d;

3255

3260

3256

if (!driver->major) {

3261

if (!driver->major) {

3257

error = alloc_chrdev_region(&dev, driver->minor_start,

3262

error = alloc_chrdev_region(&dev, driver->minor_start,

3258

driver->num, driver->name);

3263

driver->num, driver->name);

3259

if (!error) {

3264

if (!error) {

3260

driver->major = MAJOR(dev);

3265

driver->major = MAJOR(dev);

3261

driver->minor_start = MINOR(dev);

3266

driver->minor_start = MINOR(dev);

3262

}

3267

}

3263

} else {

3268

} else {

3264

dev = MKDEV(driver->major, driver->minor_start);

3269

dev = MKDEV(driver->major, driver->minor_start);

3265

error = register_chrdev_region(dev, driver->num, driver->name);

3270

error = register_chrdev_region(dev, driver->num, driver->name);

3266

}

3271

}

3267

if (error < 0)

3272

if (error < 0)

3268

goto err;

3273

goto err;

3269

3274

3270

if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {

3275

if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {

3271

error = tty_cdev_add(driver, dev, 0, driver->num);

3276

error = tty_cdev_add(driver, dev, 0, driver->num);

3272

if (error)

3277

if (error)

3273

goto err_unreg_char;

3278

goto err_unreg_char;

3274

}

3279

}

3275

3280

3276

mutex_lock(&tty_mutex);

3281

mutex_lock(&tty_mutex);

3277

list_add(&driver->tty_drivers, &tty_drivers);

3282

list_add(&driver->tty_drivers, &tty_drivers);

3278

mutex_unlock(&tty_mutex);

3283

mutex_unlock(&tty_mutex);

3279

3284

3280

if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {

3285

if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {

3281

for (i = 0; i < driver->num; i++) {

3286

for (i = 0; i < driver->num; i++) {

3282

d = tty_register_device(driver, i, NULL);

3287

d = tty_register_device(driver, i, NULL);

3283

if (IS_ERR(d)) {

3288

if (IS_ERR(d)) {

3284

error = PTR_ERR(d);

3289

error = PTR_ERR(d);

3285

goto err_unreg_devs;

3290

goto err_unreg_devs;

3286

}

3291

}

3287

}

3292

}

3288

}

3293

}

3289

proc_tty_register_driver(driver);

3294

proc_tty_register_driver(driver);

3290

driver->flags |= TTY_DRIVER_INSTALLED;

3295

driver->flags |= TTY_DRIVER_INSTALLED;

3291

return 0;

3296

return 0;

3292

3297

3293

err_unreg_devs:

3298

err_unreg_devs:

3294

for (i--; i >= 0; i--)

3299

for (i--; i >= 0; i--)

3295

tty_unregister_device(driver, i);

3300

tty_unregister_device(driver, i);

3296

3301

3297

mutex_lock(&tty_mutex);

3302

mutex_lock(&tty_mutex);

3298

list_del(&driver->tty_drivers);

3303

list_del(&driver->tty_drivers);

3299

mutex_unlock(&tty_mutex);

3304

mutex_unlock(&tty_mutex);

3300

3305

3301

err_unreg_char:

3306

err_unreg_char:

3302

unregister_chrdev_region(dev, driver->num);

3307

unregister_chrdev_region(dev, driver->num);

3303

err:

3308

err:

3304

return error;

3309

return error;

3305

}

3310

}

3306

EXPORT_SYMBOL(tty_register_driver);

3311

EXPORT_SYMBOL(tty_register_driver);

3307

3312

3308

/*

3313

/*

3309

* Called by a tty driver to unregister itself.

3314

* Called by a tty driver to unregister itself.

3310

*/

3315

*/

3311

int tty_unregister_driver(struct tty_driver *driver)

3316

int tty_unregister_driver(struct tty_driver *driver)

3312

{

3317

{

3313

#if 0

3318

#if 0

3314

/* FIXME */

3319

/* FIXME */

3315

if (driver->refcount)

3320

if (driver->refcount)

3316

return -EBUSY;

3321

return -EBUSY;

3317

#endif

3322

#endif

3318

unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),

3323

unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),

3319

driver->num);

3324

driver->num);

3320

mutex_lock(&tty_mutex);

3325

mutex_lock(&tty_mutex);

3321

list_del(&driver->tty_drivers);

3326

list_del(&driver->tty_drivers);

3322

mutex_unlock(&tty_mutex);

3327

mutex_unlock(&tty_mutex);

3323

return 0;

3328

return 0;

3324

}

3329

}

3325

3330

3326

EXPORT_SYMBOL(tty_unregister_driver);

3331

EXPORT_SYMBOL(tty_unregister_driver);

3327

3332

3328

dev_t tty_devnum(struct tty_struct *tty)

3333

dev_t tty_devnum(struct tty_struct *tty)

3329

{

3334

{

3330

return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;

3335

return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;

3331

}

3336

}

3332

EXPORT_SYMBOL(tty_devnum);

3337

EXPORT_SYMBOL(tty_devnum);

3333

3338

3334

void proc_clear_tty(struct task_struct *p)

3339

void proc_clear_tty(struct task_struct *p)

3335

{

3340

{

3336

unsigned long flags;

3341

unsigned long flags;

3337

struct tty_struct *tty;

3342

struct tty_struct *tty;

3338

spin_lock_irqsave(&p->sighand->siglock, flags);

3343

spin_lock_irqsave(&p->sighand->siglock, flags);

3339

tty = p->signal->tty;

3344

tty = p->signal->tty;

3340

p->signal->tty = NULL;

3345

p->signal->tty = NULL;

3341

spin_unlock_irqrestore(&p->sighand->siglock, flags);

3346

spin_unlock_irqrestore(&p->sighand->siglock, flags);

3342

tty_kref_put(tty);

3347

tty_kref_put(tty);

3343

}

3348

}

3344

3349

3345

/* Called under the sighand lock */

3350

/* Called under the sighand lock */

3346

3351

3347

static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)

3352

static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)

3348

{

3353

{

3349

if (tty) {

3354

if (tty) {

3350

unsigned long flags;

3355

unsigned long flags;

3351

/* We should not have a session or pgrp to put here but.... */

3356

/* We should not have a session or pgrp to put here but.... */

3352

spin_lock_irqsave(&tty->ctrl_lock, flags);

3357

spin_lock_irqsave(&tty->ctrl_lock, flags);

3353

put_pid(tty->session);

3358

put_pid(tty->session);

3354

put_pid(tty->pgrp);

3359

put_pid(tty->pgrp);

3355

tty->pgrp = get_pid(task_pgrp(tsk));

3360

tty->pgrp = get_pid(task_pgrp(tsk));

3356

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

3361

spin_unlock_irqrestore(&tty->ctrl_lock, flags);

3357

tty->session = get_pid(task_session(tsk));

3362

tty->session = get_pid(task_session(tsk));

3358

if (tsk->signal->tty) {

3363

if (tsk->signal->tty) {

3359

printk(KERN_DEBUG "tty not NULL!!\n");

3364

printk(KERN_DEBUG "tty not NULL!!\n");

3360

tty_kref_put(tsk->signal->tty);

3365

tty_kref_put(tsk->signal->tty);

3361

}

3366

}

3362

}

3367

}

3363

put_pid(tsk->signal->tty_old_pgrp);

3368

put_pid(tsk->signal->tty_old_pgrp);

3364

tsk->signal->tty = tty_kref_get(tty);

3369

tsk->signal->tty = tty_kref_get(tty);

3365

tsk->signal->tty_old_pgrp = NULL;

3370

tsk->signal->tty_old_pgrp = NULL;

3366

}

3371

}

3367

3372

3368

static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)

3373

static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)

3369

{

3374

{

3370

spin_lock_irq(&tsk->sighand->siglock);

3375

spin_lock_irq(&tsk->sighand->siglock);

3371

__proc_set_tty(tsk, tty);

3376

__proc_set_tty(tsk, tty);

3372

spin_unlock_irq(&tsk->sighand->siglock);

3377

spin_unlock_irq(&tsk->sighand->siglock);

3373

}

3378

}

3374

3379

3375

struct tty_struct *get_current_tty(void)

3380

struct tty_struct *get_current_tty(void)

3376

{

3381

{

3377

struct tty_struct *tty;

3382

struct tty_struct *tty;

3378

unsigned long flags;

3383

unsigned long flags;

3379

3384

3380

spin_lock_irqsave(&current->sighand->siglock, flags);

3385

spin_lock_irqsave(&current->sighand->siglock, flags);

3381

tty = tty_kref_get(current->signal->tty);

3386

tty = tty_kref_get(current->signal->tty);

3382

spin_unlock_irqrestore(&current->sighand->siglock, flags);

3387

spin_unlock_irqrestore(&current->sighand->siglock, flags);

3383

return tty;

3388

return tty;

3384

}

3389

}

3385

EXPORT_SYMBOL_GPL(get_current_tty);

3390

EXPORT_SYMBOL_GPL(get_current_tty);

3386

3391

3387

void tty_default_fops(struct file_operations *fops)

3392

void tty_default_fops(struct file_operations *fops)

3388

{

3393

{

3389

*fops = tty_fops;

3394

*fops = tty_fops;

3390

}

3395

}

3391

3396

3392

/*

3397

/*

3393

* Initialize the console device. This is called *early*, so

3398

* Initialize the console device. This is called *early*, so

3394

* we can't necessarily depend on lots of kernel help here.

3399

* we can't necessarily depend on lots of kernel help here.

3395

* Just do some early initializations, and do the complex setup

3400

* Just do some early initializations, and do the complex setup

3396

* later.

3401

* later.

3397

*/

3402

*/

3398

void __init console_init(void)

3403

void __init console_init(void)

3399

{

3404

{

3400

initcall_t *call;

3405

initcall_t *call;

3401

3406

3402

/* Setup the default TTY line discipline. */

3407

/* Setup the default TTY line discipline. */

3403

tty_ldisc_begin();

3408

tty_ldisc_begin();

3404

3409

3405

/*

3410

/*

3406

* set up the console device so that later boot sequences can

3411

* set up the console device so that later boot sequences can

3407

* inform about problems etc..

3412

* inform about problems etc..

3408

*/

3413

*/

3409

call = __con_initcall_start;

3414

call = __con_initcall_start;

3410

while (call < __con_initcall_end) {

3415

while (call < __con_initcall_end) {

3411

(*call)();

3416

(*call)();

3412

call++;

3417

call++;

3413

}

3418

}

3414

}

3419

}

3415

3420

3416

static char *tty_devnode(struct device *dev, umode_t *mode)

3421

static char *tty_devnode(struct device *dev, umode_t *mode)

3417

{

3422

{

3418

if (!mode)

3423

if (!mode)

3419

return NULL;

3424

return NULL;

3420

if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||

3425

if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||

3421

dev->devt == MKDEV(TTYAUX_MAJOR, 2))

3426

dev->devt == MKDEV(TTYAUX_MAJOR, 2))

3422

*mode = 0666;

3427

*mode = 0666;

3423

return NULL;

3428

return NULL;

3424

}

3429

}

3425

3430

3426

static int __init tty_class_init(void)

3431

static int __init tty_class_init(void)

3427

{

3432

{

3428

tty_class = class_create(THIS_MODULE, "tty");

3433

tty_class = class_create(THIS_MODULE, "tty");

3429

if (IS_ERR(tty_class))

3434

if (IS_ERR(tty_class))

3430

return PTR_ERR(tty_class);

3435

return PTR_ERR(tty_class);

3431

tty_class->devnode = tty_devnode;

3436

tty_class->devnode = tty_devnode;

3432

return 0;

3437

return 0;

3433

}

3438

}

3434

3439

3435

postcore_initcall(tty_class_init);

3440

postcore_initcall(tty_class_init);

3436

3441

3437

/* 3/2004 jmc: why do these devices exist? */

3442

/* 3/2004 jmc: why do these devices exist? */

3438

static struct cdev tty_cdev, console_cdev;

3443

static struct cdev tty_cdev, console_cdev;

3439

3444

3440

static ssize_t show_cons_active(struct device *dev,

3445

static ssize_t show_cons_active(struct device *dev,

3441

struct device_attribute *attr, char *buf)

3446

struct device_attribute *attr, char *buf)

3442

{

3447

{

3443

struct console *cs[16];

3448

struct console *cs[16];

3444

int i = 0;

3449

int i = 0;

3445

struct console *c;

3450

struct console *c;

3446

ssize_t count = 0;

3451

ssize_t count = 0;

3447

3452

3448

console_lock();

3453

console_lock();

3449

for_each_console(c) {

3454

for_each_console(c) {

3450

if (!c->device)

3455

if (!c->device)

3451

continue;

3456

continue;

3452

if (!c->write)

3457

if (!c->write)

3453

continue;

3458

continue;

3454

if ((c->flags & CON_ENABLED) == 0)

3459

if ((c->flags & CON_ENABLED) == 0)

3455

continue;

3460

continue;

3456

cs[i++] = c;

3461

cs[i++] = c;

3457

if (i >= ARRAY_SIZE(cs))

3462

if (i >= ARRAY_SIZE(cs))

3458

break;

3463

break;

3459

}

3464

}

3460

while (i--)

3465

while (i--)

3461

count += sprintf(buf + count, "%s%d%c",

3466

count += sprintf(buf + count, "%s%d%c",

3462

cs[i]->name, cs[i]->index, i ? ' ':'\n');

3467

cs[i]->name, cs[i]->index, i ? ' ':'\n');

3463

console_unlock();

3468

console_unlock();

3464

3469

3465

return count;

3470

return count;

3466

}

3471

}

3467

static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);

3472

static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);

3468

3473

3469

static struct device *consdev;

3474

static struct device *consdev;

3470

3475

3471

void console_sysfs_notify(void)

3476

void console_sysfs_notify(void)

3472

{

3477

{

3473

if (consdev)

3478

if (consdev)

3474

sysfs_notify(&consdev->kobj, NULL, "active");

3479

sysfs_notify(&consdev->kobj, NULL, "active");

3475

}

3480

}

3476

3481

3477

/*

3482

/*

3478

* Ok, now we can initialize the rest of the tty devices and can count

3483

* Ok, now we can initialize the rest of the tty devices and can count

3479

* on memory allocations, interrupts etc..

3484

* on memory allocations, interrupts etc..

3480

*/

3485

*/

3481

int __init tty_init(void)

3486

int __init tty_init(void)

3482

{

3487

{

3483

cdev_init(&tty_cdev, &tty_fops);

3488

cdev_init(&tty_cdev, &tty_fops);

3484

if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||

3489

if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||

3485

register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)

3490

register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)

3486

panic("Couldn't register /dev/tty driver\n");

3491

panic("Couldn't register /dev/tty driver\n");

3487

device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");

3492

device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");

3488

3493

3489

cdev_init(&console_cdev, &console_fops);

3494

cdev_init(&console_cdev, &console_fops);

3490

if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||

3495

if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||

3491

register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)

3496

register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)

3492

panic("Couldn't register /dev/console driver\n");

3497

panic("Couldn't register /dev/console driver\n");

3493

consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,

3498

consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,

3494

"console");

3499

"console");

3495

if (IS_ERR(consdev))

3500

if (IS_ERR(consdev))

3496

consdev = NULL;

3501

consdev = NULL;

3497

else

3502

else

3498

WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);

3503

WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);

3499

3504

3500

#ifdef CONFIG_VT

3505

#ifdef CONFIG_VT

3501

vty_init(&console_fops);

3506

vty_init(&console_fops);

3502

#endif

3507

#endif

3503

return 0;

3508

return 0;

3504

}

3509

}

3505

3510

3506

3511

GITLAB

tty: Add get- ioctls to fetch tty status v3

 /*
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
  *  Added support for a Unix98-style ptmx device.
  *    -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
  *
  */
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/interrupt.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/fcntl.h>
 #include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/major.h>
 #include <linux/mm.h>
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/uaccess.h>
 #include <linux/bitops.h>
 #include <linux/devpts_fs.h>
 #include <linux/slab.h>
 #include <linux/mutex.h>
 #ifdef CONFIG_UNIX98_PTYS
 static struct tty_driver *ptm_driver;
 static struct tty_driver *pts_driver;
 static DEFINE_MUTEX(devpts_mutex);
 #endif
 static void pty_close(struct tty_struct *tty, struct file *filp)
 {
 	BUG_ON(!tty);
 	if (tty->driver->subtype == PTY_TYPE_MASTER)
 		WARN_ON(tty->count > 1);
 	else {
 		if (tty->count > 2)
 			return;
 	}
 	wake_up_interruptible(&tty->read_wait);
 	wake_up_interruptible(&tty->write_wait);
 	tty->packet = 0;
 	/* Review - krefs on tty_link ?? */
 	if (!tty->link)
 		return;
 	tty->link->packet = 0;
 	set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
 	wake_up_interruptible(&tty->link->read_wait);
 	wake_up_interruptible(&tty->link->write_wait);
 	if (tty->driver->subtype == PTY_TYPE_MASTER) {
 		set_bit(TTY_OTHER_CLOSED, &tty->flags);
 #ifdef CONFIG_UNIX98_PTYS
 		if (tty->driver == ptm_driver) {
 		        mutex_lock(&devpts_mutex);
 			devpts_pty_kill(tty->link->driver_data);
 		        mutex_unlock(&devpts_mutex);
 		}
 #endif
 		tty_unlock(tty);
 		tty_vhangup(tty->link);
 		tty_lock(tty);
 	}
 }
 /*
  * The unthrottle routine is called by the line discipline to signal
  * that it can receive more characters.  For PTY's, the TTY_THROTTLED
  * flag is always set, to force the line discipline to always call the
  * unthrottle routine when there are fewer than TTY_THRESHOLD_UNTHROTTLE
  * characters in the queue.  This is necessary since each time this
  * happens, we need to wake up any sleeping processes that could be
  * (1) trying to send data to the pty, or (2) waiting in wait_until_sent()
  * for the pty buffer to be drained.
  */
 static void pty_unthrottle(struct tty_struct *tty)
 {
 	tty_wakeup(tty->link);
 	set_bit(TTY_THROTTLED, &tty->flags);
 }
 /**
  *	pty_space	-	report space left for writing
  *	@to: tty we are writing into
  *
  *	The tty buffers allow 64K but we sneak a peak and clip at 8K this
  *	allows a lot of overspill room for echo and other fun messes to
  *	be handled properly
  */
 static int pty_space(struct tty_struct *to)
 {
 	int n = 8192 - to->port->buf.memory_used;
 	if (n < 0)
 		return 0;
 	return n;
 }
 /**
  *	pty_write		-	write to a pty
  *	@tty: the tty we write from
  *	@buf: kernel buffer of data
  *	@count: bytes to write
  *
  *	Our "hardware" write method. Data is coming from the ldisc which
  *	may be in a non sleeping state. We simply throw this at the other
  *	end of the link as if we were an IRQ handler receiving stuff for
  *	the other side of the pty/tty pair.
  */
 static int pty_write(struct tty_struct *tty, const unsigned char *buf, int c)
 {
 	struct tty_struct *to = tty->link;
 	if (tty->stopped)
 		return 0;
 	if (c > 0) {
 		/* Stuff the data into the input queue of the other end */
 		c = tty_insert_flip_string(to, buf, c);
 		/* And shovel */
 		if (c) {
 			tty_flip_buffer_push(to);
 			tty_wakeup(tty);
 		}
 	}
 	return c;
 }
 /**
  *	pty_write_room	-	write space
  *	@tty: tty we are writing from
  *
  *	Report how many bytes the ldisc can send into the queue for
  *	the other device.
  */
 static int pty_write_room(struct tty_struct *tty)
 {
 	if (tty->stopped)
 		return 0;
 	return pty_space(tty->link);
 }
 /**
  *	pty_chars_in_buffer	-	characters currently in our tx queue
  *	@tty: our tty
  *
  *	Report how much we have in the transmit queue. As everything is
  *	instantly at the other end this is easy to implement.
  */
 static int pty_chars_in_buffer(struct tty_struct *tty)
 {
 	return 0;
 }
 /* Set the lock flag on a pty */
 static int pty_set_lock(struct tty_struct *tty, int __user *arg)
 {
 	int val;
 	if (get_user(val, arg))
 		return -EFAULT;
 	if (val)
 		set_bit(TTY_PTY_LOCK, &tty->flags);
 	else
 		clear_bit(TTY_PTY_LOCK, &tty->flags);
 	return 0;
 }
+static int pty_get_lock(struct tty_struct *tty, int __user *arg)
+{
+	int locked = test_bit(TTY_PTY_LOCK, &tty->flags);
+	return put_user(locked, arg);
+}
 /* Set the packet mode on a pty */
 static int pty_set_pktmode(struct tty_struct *tty, int __user *arg)
 {
 	unsigned long flags;
 	int pktmode;
 	if (get_user(pktmode, arg))
 		return -EFAULT;
 	spin_lock_irqsave(&tty->ctrl_lock, flags);
 	if (pktmode) {
 		if (!tty->packet) {
 			tty->packet = 1;
 			tty->link->ctrl_status = 0;
 		}
 	} else
 		tty->packet = 0;
 	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 	return 0;
 }
+/* Get the packet mode of a pty */
+static int pty_get_pktmode(struct tty_struct *tty, int __user *arg)
+{
+	int pktmode = tty->packet;
+	return put_user(pktmode, arg);
+}
 /* Send a signal to the slave */
 static int pty_signal(struct tty_struct *tty, int sig)
 {
 	unsigned long flags;
 	struct pid *pgrp;
 	if (tty->link) {
 		spin_lock_irqsave(&tty->link->ctrl_lock, flags);
 		pgrp = get_pid(tty->link->pgrp);
 		spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
 		kill_pgrp(pgrp, sig, 1);
 		put_pid(pgrp);
 	}
 	return 0;
 }
 static void pty_flush_buffer(struct tty_struct *tty)
 {
 	struct tty_struct *to = tty->link;
 	unsigned long flags;
 	if (!to)
 		return;
 	/* tty_buffer_flush(to); FIXME */
 	if (to->packet) {
 		spin_lock_irqsave(&tty->ctrl_lock, flags);
 		tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
 		wake_up_interruptible(&to->read_wait);
 		spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 	}
 }
 static int pty_open(struct tty_struct *tty, struct file *filp)
 {
 	int	retval = -ENODEV;
 	if (!tty || !tty->link)
 		goto out;
 	retval = -EIO;
 	if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
 		goto out;
 	if (test_bit(TTY_PTY_LOCK, &tty->link->flags))
 		goto out;
 	if (tty->link->count != 1)
 		goto out;
 	clear_bit(TTY_OTHER_CLOSED, &tty->link->flags);
 	set_bit(TTY_THROTTLED, &tty->flags);
 	retval = 0;
 out:
 	return retval;
 }
 static void pty_set_termios(struct tty_struct *tty,
 					struct ktermios *old_termios)
 {
 	tty->termios.c_cflag &= ~(CSIZE | PARENB);
 	tty->termios.c_cflag |= (CS8 | CREAD);
 }
 /**
  *	pty_do_resize		-	resize event
  *	@tty: tty being resized
  *	@ws: window size being set.
  *
  *	Update the termios variables and send the necessary signals to
  *	peform a terminal resize correctly
  */
 int pty_resize(struct tty_struct *tty,  struct winsize *ws)
 {
 	struct pid *pgrp, *rpgrp;
 	unsigned long flags;
 	struct tty_struct *pty = tty->link;
 	/* For a PTY we need to lock the tty side */
 	mutex_lock(&tty->termios_mutex);
 	if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
 		goto done;
 	/* Get the PID values and reference them so we can
 	   avoid holding the tty ctrl lock while sending signals.
 	   We need to lock these individually however. */
 	spin_lock_irqsave(&tty->ctrl_lock, flags);
 	pgrp = get_pid(tty->pgrp);
 	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 	spin_lock_irqsave(&pty->ctrl_lock, flags);
 	rpgrp = get_pid(pty->pgrp);
 	spin_unlock_irqrestore(&pty->ctrl_lock, flags);
 	if (pgrp)
 		kill_pgrp(pgrp, SIGWINCH, 1);
 	if (rpgrp != pgrp && rpgrp)
 		kill_pgrp(rpgrp, SIGWINCH, 1);
 	put_pid(pgrp);
 	put_pid(rpgrp);
 	tty->winsize = *ws;
 	pty->winsize = *ws;	/* Never used so will go away soon */
 done:
 	mutex_unlock(&tty->termios_mutex);
 	return 0;
 }
 /**
  *	pty_common_install		-	set up the pty pair
  *	@driver: the pty driver
  *	@tty: the tty being instantiated
  *	@bool: legacy, true if this is BSD style
  *
  *	Perform the initial set up for the tty/pty pair. Called from the
  *	tty layer when the port is first opened.
  *
  *	Locking: the caller must hold the tty_mutex
  */
 static int pty_common_install(struct tty_driver *driver, struct tty_struct *tty,
 		bool legacy)
 {
 	struct tty_struct *o_tty;
 	struct tty_port *ports[2];
 	int idx = tty->index;
 	int retval = -ENOMEM;
 	o_tty = alloc_tty_struct();
 	if (!o_tty)
 		goto err;
 	ports[0] = kmalloc(sizeof **ports, GFP_KERNEL);
 	ports[1] = kmalloc(sizeof **ports, GFP_KERNEL);
 	if (!ports[0] || !ports[1])
 		goto err_free_tty;
 	if (!try_module_get(driver->other->owner)) {
 		/* This cannot in fact currently happen */
 		goto err_free_tty;
 	}
 	initialize_tty_struct(o_tty, driver->other, idx);
 	if (legacy) {
 		/* We always use new tty termios data so we can do this
 		   the easy way .. */
 		retval = tty_init_termios(tty);
 		if (retval)
 			goto err_deinit_tty;
 		retval = tty_init_termios(o_tty);
 		if (retval)
 			goto err_free_termios;
 		driver->other->ttys[idx] = o_tty;
 		driver->ttys[idx] = tty;
 	} else {
 		memset(&tty->termios_locked, 0, sizeof(tty->termios_locked));
 		tty->termios = driver->init_termios;
 		memset(&o_tty->termios_locked, 0, sizeof(tty->termios_locked));
 		o_tty->termios = driver->other->init_termios;
 	}
 	/*
 	 * Everything allocated ... set up the o_tty structure.
 	 */
 	tty_driver_kref_get(driver->other);
 	if (driver->subtype == PTY_TYPE_MASTER)
 		o_tty->count++;
 	/* Establish the links in both directions */
 	tty->link   = o_tty;
 	o_tty->link = tty;
 	tty_port_init(ports[0]);
 	tty_port_init(ports[1]);
 	o_tty->port = ports[0];
 	tty->port = ports[1];
 	o_tty->port->itty = o_tty;
 	tty_driver_kref_get(driver);
 	tty->count++;
 	return 0;
 err_free_termios:
 	if (legacy)
 		tty_free_termios(tty);
 err_deinit_tty:
 	deinitialize_tty_struct(o_tty);
 	module_put(o_tty->driver->owner);
 err_free_tty:
 	kfree(ports[0]);
 	kfree(ports[1]);
 	free_tty_struct(o_tty);
 err:
 	return retval;
 }
 /* this is called once with whichever end is closed last */
 static void pty_unix98_shutdown(struct tty_struct *tty)
 {
 	devpts_kill_index(tty->driver_data, tty->index);
 }
 static void pty_cleanup(struct tty_struct *tty)
 {
 	tty->port->itty = NULL;
 	kfree(tty->port);
 }
 /* Traditional BSD devices */
 #ifdef CONFIG_LEGACY_PTYS
 static int pty_install(struct tty_driver *driver, struct tty_struct *tty)
 {
 	return pty_common_install(driver, tty, true);
 }
 static void pty_remove(struct tty_driver *driver, struct tty_struct *tty)
 {
 	struct tty_struct *pair = tty->link;
 	driver->ttys[tty->index] = NULL;
 	if (pair)
 		pair->driver->ttys[pair->index] = NULL;
 }
 static int pty_bsd_ioctl(struct tty_struct *tty,
 			 unsigned int cmd, unsigned long arg)
 {
 	switch (cmd) {
 	case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
 		return pty_set_lock(tty, (int __user *) arg);
+	case TIOCGPTLCK: /* Get PT Lock status */
+		return pty_get_lock(tty, (int __user *)arg);
 	case TIOCPKT: /* Set PT packet mode */
 		return pty_set_pktmode(tty, (int __user *)arg);
+	case TIOCGPKT: /* Get PT packet mode */
+		return pty_get_pktmode(tty, (int __user *)arg);
 	case TIOCSIG:    /* Send signal to other side of pty */
 		return pty_signal(tty, (int) arg);
 	}
 	return -ENOIOCTLCMD;
 }
 static int legacy_count = CONFIG_LEGACY_PTY_COUNT;
 module_param(legacy_count, int, 0);
 /*
  * The master side of a pty can do TIOCSPTLCK and thus
  * has pty_bsd_ioctl.
  */
 static const struct tty_operations master_pty_ops_bsd = {
 	.install = pty_install,
 	.open = pty_open,
 	.close = pty_close,
 	.write = pty_write,
 	.write_room = pty_write_room,
 	.flush_buffer = pty_flush_buffer,
 	.chars_in_buffer = pty_chars_in_buffer,
 	.unthrottle = pty_unthrottle,
 	.set_termios = pty_set_termios,
 	.ioctl = pty_bsd_ioctl,
 	.cleanup = pty_cleanup,
 	.resize = pty_resize,
 	.remove = pty_remove
 };
 static const struct tty_operations slave_pty_ops_bsd = {
 	.install = pty_install,
 	.open = pty_open,
 	.close = pty_close,
 	.write = pty_write,
 	.write_room = pty_write_room,
 	.flush_buffer = pty_flush_buffer,
 	.chars_in_buffer = pty_chars_in_buffer,
 	.unthrottle = pty_unthrottle,
 	.set_termios = pty_set_termios,
 	.cleanup = pty_cleanup,
 	.resize = pty_resize,
 	.remove = pty_remove
 };
 static void __init legacy_pty_init(void)
 {
 	struct tty_driver *pty_driver, *pty_slave_driver;
 	if (legacy_count <= 0)
 		return;
 	pty_driver = tty_alloc_driver(legacy_count,
 			TTY_DRIVER_RESET_TERMIOS |
 			TTY_DRIVER_REAL_RAW |
 			TTY_DRIVER_DYNAMIC_ALLOC);
 	if (IS_ERR(pty_driver))
 		panic("Couldn't allocate pty driver");
 	pty_slave_driver = tty_alloc_driver(legacy_count,
 			TTY_DRIVER_RESET_TERMIOS |
 			TTY_DRIVER_REAL_RAW |
 			TTY_DRIVER_DYNAMIC_ALLOC);
 	if (IS_ERR(pty_slave_driver))
 		panic("Couldn't allocate pty slave driver");
 	pty_driver->driver_name = "pty_master";
 	pty_driver->name = "pty";
 	pty_driver->major = PTY_MASTER_MAJOR;
 	pty_driver->minor_start = 0;
 	pty_driver->type = TTY_DRIVER_TYPE_PTY;
 	pty_driver->subtype = PTY_TYPE_MASTER;
 	pty_driver->init_termios = tty_std_termios;
 	pty_driver->init_termios.c_iflag = 0;
 	pty_driver->init_termios.c_oflag = 0;
 	pty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 	pty_driver->init_termios.c_lflag = 0;
 	pty_driver->init_termios.c_ispeed = 38400;
 	pty_driver->init_termios.c_ospeed = 38400;
 	pty_driver->other = pty_slave_driver;
 	tty_set_operations(pty_driver, &master_pty_ops_bsd);
 	pty_slave_driver->driver_name = "pty_slave";
 	pty_slave_driver->name = "ttyp";
 	pty_slave_driver->major = PTY_SLAVE_MAJOR;
 	pty_slave_driver->minor_start = 0;
 	pty_slave_driver->type = TTY_DRIVER_TYPE_PTY;
 	pty_slave_driver->subtype = PTY_TYPE_SLAVE;
 	pty_slave_driver->init_termios = tty_std_termios;
 	pty_slave_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 	pty_slave_driver->init_termios.c_ispeed = 38400;
 	pty_slave_driver->init_termios.c_ospeed = 38400;
 	pty_slave_driver->other = pty_driver;
 	tty_set_operations(pty_slave_driver, &slave_pty_ops_bsd);
 	if (tty_register_driver(pty_driver))
 		panic("Couldn't register pty driver");
 	if (tty_register_driver(pty_slave_driver))
 		panic("Couldn't register pty slave driver");
 }
 #else
 static inline void legacy_pty_init(void) { }
 #endif
 /* Unix98 devices */
 #ifdef CONFIG_UNIX98_PTYS
 static struct cdev ptmx_cdev;
 static int pty_unix98_ioctl(struct tty_struct *tty,
 			    unsigned int cmd, unsigned long arg)
 {
 	switch (cmd) {
 	case TIOCSPTLCK: /* Set PT Lock (disallow slave open) */
 		return pty_set_lock(tty, (int __user *)arg);
+	case TIOCGPTLCK: /* Get PT Lock status */
+		return pty_get_lock(tty, (int __user *)arg);
 	case TIOCPKT: /* Set PT packet mode */
 		return pty_set_pktmode(tty, (int __user *)arg);
+	case TIOCGPKT: /* Get PT packet mode */
+		return pty_get_pktmode(tty, (int __user *)arg);
 	case TIOCGPTN: /* Get PT Number */
 		return put_user(tty->index, (unsigned int __user *)arg);
 	case TIOCSIG:    /* Send signal to other side of pty */
 		return pty_signal(tty, (int) arg);
 	}
 	return -ENOIOCTLCMD;
 }
 /**
  *	ptm_unix98_lookup	-	find a pty master
  *	@driver: ptm driver
  *	@idx: tty index
  *
  *	Look up a pty master device. Called under the tty_mutex for now.
  *	This provides our locking.
  */
 static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
 		struct inode *ptm_inode, int idx)
 {
 	/* Master must be open via /dev/ptmx */
 	return ERR_PTR(-EIO);
 }
 /**
  *	pts_unix98_lookup	-	find a pty slave
  *	@driver: pts driver
  *	@idx: tty index
  *
  *	Look up a pty master device. Called under the tty_mutex for now.
  *	This provides our locking for the tty pointer.
  */
 static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
 		struct inode *pts_inode, int idx)
 {
 	struct tty_struct *tty;
 	mutex_lock(&devpts_mutex);
 	tty = devpts_get_priv(pts_inode);
 	mutex_unlock(&devpts_mutex);
 	/* Master must be open before slave */
 	if (!tty)
 		return ERR_PTR(-EIO);
 	return tty;
 }
 /* We have no need to install and remove our tty objects as devpts does all
    the work for us */
 static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
 {
 	return pty_common_install(driver, tty, false);
 }
 static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
 {
 }
 static const struct tty_operations ptm_unix98_ops = {
 	.lookup = ptm_unix98_lookup,
 	.install = pty_unix98_install,
 	.remove = pty_unix98_remove,
 	.open = pty_open,
 	.close = pty_close,
 	.write = pty_write,
 	.write_room = pty_write_room,
 	.flush_buffer = pty_flush_buffer,
 	.chars_in_buffer = pty_chars_in_buffer,
 	.unthrottle = pty_unthrottle,
 	.set_termios = pty_set_termios,
 	.ioctl = pty_unix98_ioctl,
 	.resize = pty_resize,
 	.shutdown = pty_unix98_shutdown,
 	.cleanup = pty_cleanup
 };
 static const struct tty_operations pty_unix98_ops = {
 	.lookup = pts_unix98_lookup,
 	.install = pty_unix98_install,
 	.remove = pty_unix98_remove,
 	.open = pty_open,
 	.close = pty_close,
 	.write = pty_write,
 	.write_room = pty_write_room,
 	.flush_buffer = pty_flush_buffer,
 	.chars_in_buffer = pty_chars_in_buffer,
 	.unthrottle = pty_unthrottle,
 	.set_termios = pty_set_termios,
 	.shutdown = pty_unix98_shutdown,
 	.cleanup = pty_cleanup,
 };
 /**
  *	ptmx_open		-	open a unix 98 pty master
  *	@inode: inode of device file
  *	@filp: file pointer to tty
  *
  *	Allocate a unix98 pty master device from the ptmx driver.
  *
  *	Locking: tty_mutex protects the init_dev work. tty->count should
  * 		protect the rest.
  *		allocated_ptys_lock handles the list of free pty numbers
  */
 static int ptmx_open(struct inode *inode, struct file *filp)
 {
 	struct tty_struct *tty;
 	struct inode *slave_inode;
 	int retval;
 	int index;
 	nonseekable_open(inode, filp);
 	retval = tty_alloc_file(filp);
 	if (retval)
 		return retval;
 	/* find a device that is not in use. */
 	mutex_lock(&devpts_mutex);
 	index = devpts_new_index(inode);
 	if (index < 0) {
 		retval = index;
 		mutex_unlock(&devpts_mutex);
 		goto err_file;
 	}
 	mutex_unlock(&devpts_mutex);
 	mutex_lock(&tty_mutex);
 	tty = tty_init_dev(ptm_driver, index);
 	if (IS_ERR(tty)) {
 		retval = PTR_ERR(tty);
 		goto out;
 	}
 	/* The tty returned here is locked so we can safely
 	   drop the mutex */
 	mutex_unlock(&tty_mutex);
 	set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
 	tty_add_file(tty, filp);
 	slave_inode = devpts_pty_new(inode,
 			MKDEV(UNIX98_PTY_SLAVE_MAJOR, index), index,
 			tty->link);
 	if (IS_ERR(slave_inode)) {
 		retval = PTR_ERR(slave_inode);
 		goto err_release;
 	}
 	retval = ptm_driver->ops->open(tty, filp);
 	if (retval)
 		goto err_release;
 	tty_unlock(tty);
 	tty->driver_data = inode;
 	tty->link->driver_data = slave_inode;
 	return 0;
 err_release:
 	tty_unlock(tty);
 	tty_release(inode, filp);
 	return retval;
 out:
 	mutex_unlock(&tty_mutex);
 	devpts_kill_index(inode, index);
 err_file:
 	tty_free_file(filp);
 	return retval;
 }
 static struct file_operations ptmx_fops;
 static void __init unix98_pty_init(void)
 {
 	ptm_driver = tty_alloc_driver(NR_UNIX98_PTY_MAX,
 			TTY_DRIVER_RESET_TERMIOS |
 			TTY_DRIVER_REAL_RAW |
 			TTY_DRIVER_DYNAMIC_DEV |
 			TTY_DRIVER_DEVPTS_MEM |
 			TTY_DRIVER_DYNAMIC_ALLOC);
 	if (IS_ERR(ptm_driver))
 		panic("Couldn't allocate Unix98 ptm driver");
 	pts_driver = tty_alloc_driver(NR_UNIX98_PTY_MAX,
 			TTY_DRIVER_RESET_TERMIOS |
 			TTY_DRIVER_REAL_RAW |
 			TTY_DRIVER_DYNAMIC_DEV |
 			TTY_DRIVER_DEVPTS_MEM |
 			TTY_DRIVER_DYNAMIC_ALLOC);
 	if (IS_ERR(pts_driver))
 		panic("Couldn't allocate Unix98 pts driver");
 	ptm_driver->driver_name = "pty_master";
 	ptm_driver->name = "ptm";
 	ptm_driver->major = UNIX98_PTY_MASTER_MAJOR;
 	ptm_driver->minor_start = 0;
 	ptm_driver->type = TTY_DRIVER_TYPE_PTY;
 	ptm_driver->subtype = PTY_TYPE_MASTER;
 	ptm_driver->init_termios = tty_std_termios;
 	ptm_driver->init_termios.c_iflag = 0;
 	ptm_driver->init_termios.c_oflag = 0;
 	ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 	ptm_driver->init_termios.c_lflag = 0;
 	ptm_driver->init_termios.c_ispeed = 38400;
 	ptm_driver->init_termios.c_ospeed = 38400;
 	ptm_driver->other = pts_driver;
 	tty_set_operations(ptm_driver, &ptm_unix98_ops);
 	pts_driver->driver_name = "pty_slave";
 	pts_driver->name = "pts";
 	pts_driver->major = UNIX98_PTY_SLAVE_MAJOR;
 	pts_driver->minor_start = 0;
 	pts_driver->type = TTY_DRIVER_TYPE_PTY;
 	pts_driver->subtype = PTY_TYPE_SLAVE;
 	pts_driver->init_termios = tty_std_termios;
 	pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD;
 	pts_driver->init_termios.c_ispeed = 38400;
 	pts_driver->init_termios.c_ospeed = 38400;
 	pts_driver->other = ptm_driver;
 	tty_set_operations(pts_driver, &pty_unix98_ops);
 	if (tty_register_driver(ptm_driver))
 		panic("Couldn't register Unix98 ptm driver");
 	if (tty_register_driver(pts_driver))
 		panic("Couldn't register Unix98 pts driver");
 	/* Now create the /dev/ptmx special device */
 	tty_default_fops(&ptmx_fops);
 	ptmx_fops.open = ptmx_open;
 	cdev_init(&ptmx_cdev, &ptmx_fops);
 	if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
 	    register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
 		panic("Couldn't register /dev/ptmx driver\n");
 	device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
 }
 #else
 static inline void unix98_pty_init(void) { }
 #endif
 static int __init pty_init(void)
 {
 	legacy_pty_init();
 	unix98_pty_init();
 	return 0;
 }
 module_init(pty_init);

 /*
  *  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
 #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
 };
 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. This is shared with
    vt.c for deeply disgusting hack reasons */
 DEFINE_MUTEX(tty_mutex);
 EXPORT_SYMBOL(tty_mutex);
 /* Spinlock to protect the tty->tty_files list */
 DEFINE_SPINLOCK(tty_files_lock);
 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);
 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
 /**
  *	alloc_tty_struct	-	allocate a tty object
  *
  *	Return a new empty tty structure. The data fields have not
  *	been initialized in any way but has been zeroed
  *
  *	Locking: none
  */
 struct tty_struct *alloc_tty_struct(void)
 {
 	return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
 }
 /**
  *	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
  */
 void free_tty_struct(struct tty_struct *tty)
 {
 	if (!tty)
 		return;
 	if (tty->dev)
 		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 */
 void tty_del_file(struct file *file)
 {
 	struct tty_file_private *priv = file->private_data;
 	spin_lock(&tty_files_lock);
 	list_del(&priv->list);
 	spin_unlock(&tty_files_lock);
 	tty_free_file(file);
 }
 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
 /**
  *	tty_name	-	return tty naming
  *	@tty: tty structure
  *	@buf: buffer for output
  *
  *	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
  */
 char *tty_name(struct tty_struct *tty, char *buf)
 {
 	if (!tty) /* Hmm.  NULL pointer.  That's fun. */
 		strcpy(buf, "NULL tty");
 	else
 		strcpy(buf, tty->name);
 	return buf;
 }
 EXPORT_SYMBOL(tty_name);
 int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
 			      const char *routine)
 {
 #ifdef TTY_PARANOIA_CHECK
 	if (!tty) {
 		printk(KERN_WARNING
 			"null TTY for (%d:%d) in %s\n",
 			imajor(inode), iminor(inode), routine);
 		return 1;
 	}
 	if (tty->magic != TTY_MAGIC) {
 		printk(KERN_WARNING
 			"bad magic number for tty struct (%d:%d) in %s\n",
 			imajor(inode), iminor(inode), routine);
 		return 1;
 	}
 #endif
 	return 0;
 }
 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) {
 		printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
 				    "!= #fd's(%d) in %s\n",
 		       tty->name, tty->count, count, routine);
 		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
 /**
  *	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)
 {
 	unsigned long flags;
 	int ret = 0;
 	if (current->signal->tty != tty)
 		return 0;
 	spin_lock_irqsave(&tty->ctrl_lock, flags);
 	if (!tty->pgrp) {
 		printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
 		goto out_unlock;
 	}
 	if (task_pgrp(current) == tty->pgrp)
 		goto out_unlock;
 	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 	if (is_ignored(SIGTTOU))
 		goto out;
 	if (is_current_pgrp_orphaned()) {
 		ret = -EIO;
 		goto out;
 	}
 	kill_pgrp(task_pgrp(current), SIGTTOU, 1);
 	set_thread_flag(TIF_SIGPENDING);
 	ret = -ERESTARTSYS;
 out:
 	return ret;
 out_unlock:
 	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 	return ret;
 }
 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 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,
 };
 static DEFINE_SPINLOCK(redirect_lock);
 static struct file *redirect;
 /**
  *	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_hangup		-	actual handler for hangup events
  *	@work: tty device
  *
  *	This can be called by the "eventd" 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_ldisc_lock from called functions
  *		  termios_mutex resetting termios data
  *		  tasklist_lock to walk task list for hangup event
  *		    ->siglock to protect ->signal/->sighand
  */
 void __tty_hangup(struct tty_struct *tty)
 {
 	struct file *cons_filp = NULL;
 	struct file *filp, *f = NULL;
 	struct task_struct *p;
 	struct tty_file_private *priv;
 	int    closecount = 0, n;
 	unsigned long flags;
 	int refs = 0;
 	if (!tty)
 		return;
 	spin_lock(&redirect_lock);
 	if (redirect && file_tty(redirect) == tty) {
 		f = redirect;
 		redirect = NULL;
 	}
 	spin_unlock(&redirect_lock);
 	tty_lock(tty);
 	/* some functions below drop BTM, so we need this bit */
 	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);
 	/*
 	 * it drops BTM and thus races with reopen
 	 * we protect the race by TTY_HUPPING
 	 */
 	tty_ldisc_hangup(tty);
 	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_irqsave(&tty->ctrl_lock, flags);
 			if (tty->pgrp)
 				p->signal->tty_old_pgrp = get_pid(tty->pgrp);
 			spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 			spin_unlock_irq(&p->sighand->siglock);
 		} while_each_pid_task(tty->session, PIDTYPE_SID, p);
 	}
 	read_unlock(&tasklist_lock);
 	spin_lock_irqsave(&tty->ctrl_lock, flags);
 	clear_bit(TTY_THROTTLED, &tty->flags);
 	clear_bit(TTY_PUSH, &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_irqrestore(&tty->ctrl_lock, flags);
 	/* Account for the p->signal references we killed */
 	while (refs--)
 		tty_kref_put(tty);
 	/*
 	 * 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. However we
 	 * can't yet guarantee all that.
 	 */
 	set_bit(TTY_HUPPED, &tty->flags);
 	clear_bit(TTY_HUPPING, &tty->flags);
 	tty_ldisc_enable(tty);
 	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);
 }
 /**
  *	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)
 {
 #ifdef TTY_DEBUG_HANGUP
 	char	buf[64];
 	printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
 #endif
 	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)
 {
 #ifdef TTY_DEBUG_HANGUP
 	char	buf[64];
 	printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
 #endif
 	__tty_hangup(tty);
 }
 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_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);
 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);
 }
 /**
  *	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) {
 		struct pid *tty_pgrp = get_pid(tty->pgrp);
 		if (on_exit) {
 			if (tty->driver->type != TTY_DRIVER_TYPE_PTY)
 				tty_vhangup(tty);
 		}
 		tty_kref_put(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);
 		}
 	} else if (on_exit) {
 		struct pid *old_pgrp;
 		spin_lock_irq(&current->sighand->siglock);
 		old_pgrp = current->signal->tty_old_pgrp;
 		current->signal->tty_old_pgrp = NULL;
 		spin_unlock_irq(&current->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(&current->sighand->siglock);
 	put_pid(current->signal->tty_old_pgrp);
 	current->signal->tty_old_pgrp = NULL;
 	spin_unlock_irq(&current->sighand->siglock);
 	tty = get_current_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 {
 #ifdef TTY_DEBUG_HANGUP
 		printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
 		       " = NULL", tty);
 #endif
 	}
 	/* 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. For PTY/TTY pairs we
  *	must also propagate the TIOCKPKT status. 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:
  *		Uses the tty control lock internally
  */
 void stop_tty(struct tty_struct *tty)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&tty->ctrl_lock, flags);
 	if (tty->stopped) {
 		spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 		return;
 	}
 	tty->stopped = 1;
 	if (tty->link && tty->link->packet) {
 		tty->ctrl_status &= ~TIOCPKT_START;
 		tty->ctrl_status |= TIOCPKT_STOP;
 		wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
 	}
 	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 	if (tty->ops->stop)
 		(tty->ops->stop)(tty);
 }
 EXPORT_SYMBOL(stop_tty);
 /**
  *	start_tty	-	propagate flow control
  *	@tty: tty to start
  *
  *	Start a tty that has been stopped if at all possible. Perform
  *	any necessary wakeups and propagate the TIOCPKT status. If this
  *	is the tty was previous stopped and is being started then the
  *	driver start method is invoked and the line discipline woken.
  *
  *	Locking:
  *		ctrl_lock
  */
 void start_tty(struct tty_struct *tty)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&tty->ctrl_lock, flags);
 	if (!tty->stopped || tty->flow_stopped) {
 		spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 		return;
 	}
 	tty->stopped = 0;
 	if (tty->link && tty->link->packet) {
 		tty->ctrl_status &= ~TIOCPKT_STOP;
 		tty->ctrl_status |= TIOCPKT_START;
 		wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
 	}
 	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 	if (tty->ops->start)
 		(tty->ops->start)(tty);
 	/* If we have a running line discipline it may need kicking */
 	tty_wakeup(tty);
 }
 EXPORT_SYMBOL(start_tty);
 /**
  *	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->f_path.dentry->d_inode;
 	struct tty_struct *tty = file_tty(file);
 	struct tty_ldisc *ld;
 	if (tty_paranoia_check(tty, inode, "tty_read"))
 		return -EIO;
 	if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
 		return -EIO;
 	/* We want to wait for the line discipline to sort out in this
 	   situation */
 	ld = tty_ldisc_ref_wait(tty);
 	if (ld->ops->read)
 		i = (ld->ops->read)(tty, file, buf, count);
 	else
 		i = -EIO;
 	tty_ldisc_deref(ld);
 	if (i > 0)
 		inode->i_atime = current_fs_time(inode->i_sb);
 	return i;
 }
 void tty_write_unlock(struct tty_struct *tty)
 	__releases(&tty->atomic_write_lock)
 {
 	mutex_unlock(&tty->atomic_write_lock);
 	wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
 }
 int tty_write_lock(struct tty_struct *tty, int ndelay)
 	__acquires(&tty->atomic_write_lock)
 {
 	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) {
 		struct inode *inode = file->f_path.dentry->d_inode;
 		inode->i_mtime = current_fs_time(inode->i_sb);
 		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 && !test_bit(TTY_CLOSING, &tty->flags)) {
 			tty_unlock(tty);
 			tty->ops->write(tty, msg, strlen(msg));
 		} else
 			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 inode *inode = file->f_path.dentry->d_inode;
 	struct tty_struct *tty = file_tty(file);
  	struct tty_ldisc *ld;
 	ssize_t ret;
 	if (tty_paranoia_check(tty, inode, "tty_write"))
 		return -EIO;
 	if (!tty || !tty->ops->write ||
 		(test_bit(TTY_IO_ERROR, &tty->flags)))
 			return -EIO;
 	/* Short term debug to catch buggy drivers */
 	if (tty->ops->write_room == NULL)
 		printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
 			tty->driver->name);
 	ld = tty_ldisc_ref_wait(tty);
 	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);
 }
 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 void tty_line_name(struct tty_driver *driver, int index, char *p)
 {
 	if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
 		strcpy(p, driver->name);
 	else
 		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 or ERR_PTR() otherwise.
  *
  *	Locking: tty_mutex must be held. If tty is found, the mutex must
  *	be held until the 'fast-open' is also done. Will change once we
  *	have refcounting in the driver and per driver locking
  */
 static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
 		struct inode *inode, int idx)
 {
 	if (driver->ops->lookup)
 		return driver->ops->lookup(driver, inode, idx);
 	return driver->ttys[idx];
 }
 /**
  *	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.
  */
 int 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;
 		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);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(tty_init_termios);
 int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
 {
 	int ret = tty_init_termios(tty);
 	if (ret)
 		return ret;
 	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
  */
 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.
  *
  *	Locking: tty_mutex must be held from the time the tty was found
  *		 till this open completes.
  */
 static int tty_reopen(struct tty_struct *tty)
 {
 	struct tty_driver *driver = tty->driver;
 	if (test_bit(TTY_CLOSING, &tty->flags) ||
 			test_bit(TTY_HUPPING, &tty->flags) ||
 			test_bit(TTY_LDISC_CHANGING, &tty->flags))
 		return -EIO;
 	if (driver->type == TTY_DRIVER_TYPE_PTY &&
 	    driver->subtype == PTY_TYPE_MASTER) {
 		/*
 		 * special case for PTY masters: only one open permitted,
 		 * and the slave side open count is incremented as well.
 		 */
 		if (tty->count)
 			return -EIO;
 		tty->link->count++;
 	}
 	tty->count++;
 	mutex_lock(&tty->ldisc_mutex);
 	WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
 	mutex_unlock(&tty->ldisc_mutex);
 	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();
 	if (!tty) {
 		retval = -ENOMEM;
 		goto err_module_put;
 	}
 	initialize_tty_struct(tty, driver, idx);
 	tty_lock(tty);
 	retval = tty_driver_install_tty(driver, tty);
 	if (retval < 0)
 		goto err_deinit_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);
 	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;
 	/* Return the tty locked so that it cannot vanish under the caller */
 	return tty;
 err_deinit_tty:
 	tty_unlock(tty);
 	deinitialize_tty_struct(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_unlock(tty);
 	printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "
 				 "clearing slot %d\n", idx);
 	release_tty(tty, idx);
 	return ERR_PTR(retval);
 }
 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) {
 			pr_warn("tty: no memory to save termios state.\n");
 			return;
 		}
 		tty->driver->termios[idx] = tp;
 	}
 	*tp = tty->termios;
 }
 EXPORT_SYMBOL(tty_free_termios);
 /**
  *	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;
 	if (tty->ops->cleanup)
 		tty->ops->cleanup(tty);
 	tty->magic = 0;
 	tty_driver_kref_put(driver);
 	module_put(driver->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_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, struct tty_struct *o_tty,
 		int idx)
 {
 #ifdef TTY_PARANOIA_CHECK
 	if (idx < 0 || idx >= tty->driver->num) {
 		printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",
 				__func__, tty->name);
 		return -1;
 	}
 	/* not much to check for devpts */
 	if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
 		return 0;
 	if (tty != tty->driver->ttys[idx]) {
 		printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",
 				__func__, idx, tty->name);
 		return -1;
 	}
 	if (tty->driver->other) {
 		if (o_tty != tty->driver->other->ttys[idx]) {
 			printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",
 					__func__, idx, tty->name);
 			return -1;
 		}
 		if (o_tty->link != tty) {
 			printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);
 			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;
 	int	pty_master, tty_closing, o_tty_closing, do_sleep;
 	int	idx;
 	char	buf[64];
 	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;
 	pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 		      tty->driver->subtype == PTY_TYPE_MASTER);
 	/* Review: parallel close */
 	o_tty = tty->link;
 	if (tty_release_checks(tty, o_tty, idx)) {
 		tty_unlock(tty);
 		return 0;
 	}
 #ifdef TTY_DEBUG_HANGUP
 	printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,
 			tty_name(tty, buf), tty->count);
 #endif
 	if (tty->ops->close)
 		tty->ops->close(tty, filp);
 	tty_unlock(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 closes,
 	 * so we do it now.
 	 *
 	 * Note that it's possible for the tty to be opened again while we're
 	 * flushing out waiters.  By recalculating the closing flags before
 	 * each iteration we avoid any problems.
 	 */
 	while (1) {
 		/* Guard against races with tty->count changes elsewhere and
 		   opens on /dev/tty */
 		mutex_lock(&tty_mutex);
 		tty_lock_pair(tty, o_tty);
 		tty_closing = tty->count <= 1;
 		o_tty_closing = o_tty &&
 			(o_tty->count <= (pty_master ? 1 : 0));
 		do_sleep = 0;
 		if (tty_closing) {
 			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_closing) {
 			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;
 		printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",
 				__func__, tty_name(tty, buf));
 		tty_unlock_pair(tty, o_tty);
 		mutex_unlock(&tty_mutex);
 		schedule();
 	}
 	/*
 	 * The closing flags are now consistent with the open counts on
 	 * both sides, and we've completed the last operation that could
 	 * block, so it's safe to proceed with closing.
 	 *
 	 * We must *not* drop the tty_mutex until we ensure that a further
 	 * entry into tty_open can not pick up this tty.
 	 */
 	if (pty_master) {
 		if (--o_tty->count < 0) {
 			printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",
 				__func__, o_tty->count, tty_name(o_tty, buf));
 			o_tty->count = 0;
 		}
 	}
 	if (--tty->count < 0) {
 		printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",
 				__func__, tty->count, tty_name(tty, buf));
 		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.
 	 *
 	 * Set the TTY_CLOSING flag if this was the last open.  In the
 	 * case of a pty we may have to wait around for the other side
 	 * to close, and TTY_CLOSING makes sure we can't be reopened.
 	 */
 	if (tty_closing)
 		set_bit(TTY_CLOSING, &tty->flags);
 	if (o_tty_closing)
 		set_bit(TTY_CLOSING, &o_tty->flags);
 	/*
 	 * 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_closing || o_tty_closing) {
 		read_lock(&tasklist_lock);
 		session_clear_tty(tty->session);
 		if (o_tty)
 			session_clear_tty(o_tty->session);
 		read_unlock(&tasklist_lock);
 	}
 	mutex_unlock(&tty_mutex);
 	tty_unlock_pair(tty, o_tty);
 	/* At this point the TTY_CLOSING flag should ensure a dead tty
 	   cannot be re-opened by a racing opener */
 	/* check whether both sides are closing ... */
 	if (!tty_closing || (o_tty && !o_tty_closing))
 		return 0;
 #ifdef TTY_DEBUG_HANGUP
 	printk(KERN_DEBUG "%s: freeing tty structure...\n", __func__);
 #endif
 	/*
 	 * Ask the line discipline code to release its structures
 	 */
 	tty_ldisc_release(tty, o_tty);
 	/*
 	 * 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 tty of current task for open
  *	@device: device number
  *	@filp: file pointer to tty
  *	@return: tty of the current task iff @device is /dev/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.
  *
  *	We need to move to returning a refcounted object from all the lookup
  *	paths including this one.
  */
 static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
 {
 	struct tty_struct *tty;
 	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_kref_put(tty);
 	/* FIXME: we put a reference and return a TTY! */
 	/* This is only safe because the caller holds tty_mutex */
 	return tty;
 }
 /**
  *	tty_lookup_driver - lookup a tty driver for a given device file
  *	@device: device number
  *	@filp: file pointer to tty
  *	@noctty: set if the device should not become a controlling 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 *noctty, 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;
 		*noctty = 1;
 		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;
 				*noctty = 1;
 				break;
 			}
 		}
 		return ERR_PTR(-ENODEV);
 	}
 	default:
 		driver = get_tty_driver(device, index);
 		if (!driver)
 			return ERR_PTR(-ENODEV);
 		break;
 	}
 	return driver;
 }
 /**
  *	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;
 	struct tty_driver *driver = NULL;
 	int index;
 	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;
 	noctty = filp->f_flags & O_NOCTTY;
 	index  = -1;
 	retval = 0;
 	mutex_lock(&tty_mutex);
 	/* This is protected by the tty_mutex */
 	tty = tty_open_current_tty(device, filp);
 	if (IS_ERR(tty)) {
 		retval = PTR_ERR(tty);
 		goto err_unlock;
 	} else if (!tty) {
 		driver = tty_lookup_driver(device, filp, &noctty, &index);
 		if (IS_ERR(driver)) {
 			retval = PTR_ERR(driver);
 			goto err_unlock;
 		}
 		/* check whether we're reopening an existing tty */
 		tty = tty_driver_lookup_tty(driver, inode, index);
 		if (IS_ERR(tty)) {
 			retval = PTR_ERR(tty);
 			goto err_unlock;
 		}
 	}
 	if (tty) {
 		tty_lock(tty);
 		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);
 	if (driver)
 		tty_driver_kref_put(driver);
 	if (IS_ERR(tty)) {
 		retval = PTR_ERR(tty);
 		goto err_file;
 	}
 	tty_add_file(tty, filp);
 	check_tty_count(tty, __func__);
 	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 	    tty->driver->subtype == PTY_TYPE_MASTER)
 		noctty = 1;
 #ifdef TTY_DEBUG_HANGUP
 	printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);
 #endif
 	if (tty->ops->open)
 		retval = tty->ops->open(tty, filp);
 	else
 		retval = -ENODEV;
 	filp->f_flags = saved_flags;
 	if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
 						!capable(CAP_SYS_ADMIN))
 		retval = -EBUSY;
 	if (retval) {
 #ifdef TTY_DEBUG_HANGUP
 		printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,
 				retval, tty->name);
 #endif
 		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 (filp->f_op == &hung_up_tty_fops)
 			filp->f_op = &tty_fops;
 		goto retry_open;
 	}
 	tty_unlock(tty);
 	mutex_lock(&tty_mutex);
 	tty_lock(tty);
 	spin_lock_irq(&current->sighand->siglock);
 	if (!noctty &&
 	    current->signal->leader &&
 	    !current->signal->tty &&
 	    tty->session == NULL)
 		__proc_set_tty(current, tty);
 	spin_unlock_irq(&current->sighand->siglock);
 	tty_unlock(tty);
 	mutex_unlock(&tty_mutex);
 	return 0;
 err_unlock:
 	mutex_unlock(&tty_mutex);
 	/* after locks to avoid deadlock */
 	if (!IS_ERR_OR_NULL(driver))
 		tty_driver_kref_put(driver);
 err_file:
 	tty_free_file(filp);
 	return retval;
 }
 /**
  *	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, filp->f_path.dentry->d_inode, "tty_poll"))
 		return 0;
 	ld = tty_ldisc_ref_wait(tty);
 	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, filp->f_path.dentry->d_inode, "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;
 		if (!waitqueue_active(&tty->read_wait))
 			tty->minimum_to_wake = 1;
 		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);
 		retval = __f_setown(filp, pid, type, 0);
 		put_pid(pid);
 		if (retval)
 			goto out;
 	} else {
 		if (!tty->fasync && !waitqueue_active(&tty->read_wait))
 			tty->minimum_to_wake = N_TTY_BUF_SIZE;
 	}
 	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;
 	tty_lock(tty);
 	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_ldisc_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);
 	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->termios_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->termios_mutex);
 	err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
 	mutex_unlock(&tty->termios_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;
 	unsigned long flags;
 	/* Lock the tty */
 	mutex_lock(&tty->termios_mutex);
 	if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
 		goto done;
 	/* Get the PID values and reference them so we can
 	   avoid holding the tty ctrl lock while sending signals */
 	spin_lock_irqsave(&tty->ctrl_lock, flags);
 	pgrp = get_pid(tty->pgrp);
 	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 	if (pgrp)
 		kill_pgrp(pgrp, SIGWINCH, 1);
 	put_pid(pgrp);
 	tty->winsize = *ws;
 done:
 	mutex_unlock(&tty->termios_mutex);
 	return 0;
 }
 /**
  *	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_mutex() to protect tty instance
  *		Takes tasklist_lock internally to walk sessions
  *		Takes ->siglock() when updating signal->tty
  */
 static int tiocsctty(struct tty_struct *tty, int arg)
 {
 	int ret = 0;
 	if (current->signal->leader && (task_session(current) == tty->session))
 		return ret;
 	mutex_lock(&tty_mutex);
 	/*
 	 * 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
 			 */
 			read_lock(&tasklist_lock);
 			session_clear_tty(tty->session);
 			read_unlock(&tasklist_lock);
 		} else {
 			ret = -EPERM;
 			goto unlock;
 		}
 	}
 	proc_set_tty(current, tty);
 unlock:
 	mutex_unlock(&tty_mutex);
 	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);
 /**
  *	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);
 	unsigned long flags;
 	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_irqsave(&tty->ctrl_lock, flags);
 	put_pid(real_tty->pgrp);
 	real_tty->pgrp = get_pid(pgrp);
 	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 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 ldisc;
 	int ret;
 	if (get_user(ldisc, p))
 		return -EFAULT;
 	ret = tty_set_ldisc(tty, ldisc);
 	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;
 }
 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;
 }
 EXPORT_SYMBOL(tty_pair_get_tty);
 struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
 {
 	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 	    tty->driver->subtype == PTY_TYPE_MASTER)
 	    return tty;
 	return tty->link;
 }
 EXPORT_SYMBOL(tty_pair_get_pty);
 /*
  * 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;
 	struct inode *inode = file->f_dentry->d_inode;
 	if (tty_paranoia_check(tty, inode, "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(tty, 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 put_user(tty->ldisc->ops->num, (int __user *)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);
 			break;
 		}
 		break;
 	}
 	if (tty->ops->ioctl) {
 		retval = (tty->ops->ioctl)(tty, cmd, arg);
 		if (retval != -ENOIOCTLCMD)
 			return retval;
 	}
 	ld = tty_ldisc_ref_wait(tty);
 	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 inode *inode = file->f_dentry->d_inode;
 	struct tty_struct *tty = file_tty(file);
 	struct tty_ldisc *ld;
 	int retval = -ENOIOCTLCMD;
 	if (tty_paranoia_check(tty, inode, "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->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) {
 		printk(KERN_NOTICE "SAK: killed process %d"
 			" (%s): task_session(p)==tty->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) {
 			printk(KERN_NOTICE "SAK: killed process %d"
 			    " (%s): task_session(p)==tty->session\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) {
 			printk(KERN_NOTICE "SAK: killed process %d"
 			    " (%s): fd#%d opened to the tty\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, void *data)
 {
 	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);
 }
 /**
  *	initialize_tty_struct
  *	@tty: tty to initialize
  *
  *	This subroutine initializes a tty structure that has been newly
  *	allocated.
  *
  *	Locking: none - tty in question must not be exposed at this point
  */
 void initialize_tty_struct(struct tty_struct *tty,
 		struct tty_driver *driver, int idx)
 {
 	memset(tty, 0, sizeof(struct tty_struct));
 	kref_init(&tty->kref);
 	tty->magic = TTY_MAGIC;
 	tty_ldisc_init(tty);
 	tty->session = NULL;
 	tty->pgrp = NULL;
 	mutex_init(&tty->legacy_mutex);
 	mutex_init(&tty->termios_mutex);
 	mutex_init(&tty->ldisc_mutex);
 	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);
 	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);
 }
 /**
  *	deinitialize_tty_struct
  *	@tty: tty to deinitialize
  *
  *	This subroutine deinitializes a tty structure that has been newly
  *	allocated but tty_release cannot be called on that yet.
  *
  *	Locking: none - tty in question must not be exposed at this point
  */
 void deinitialize_tty_struct(struct tty_struct *tty)
 {
 	tty_ldisc_deinit(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)
 {
 	/* init here, since reused cdevs cause crashes */
 	cdev_init(&driver->cdevs[index], &tty_fops);
 	driver->cdevs[index].owner = driver->owner;
 	return cdev_add(&driver->cdevs[index], dev, count);
 }
 /**
  *	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)
 {
 	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
 	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) {
 		printk(KERN_ERR "Attempt to register invalid tty line number "
 		       " (%d).\n", 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]);
 	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]);
 }
 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);
 	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 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);
 }
 /* Called under the sighand lock */
 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
 {
 	if (tty) {
 		unsigned long flags;
 		/* We should not have a session or pgrp to put here but.... */
 		spin_lock_irqsave(&tty->ctrl_lock, flags);
 		put_pid(tty->session);
 		put_pid(tty->pgrp);
 		tty->pgrp = get_pid(task_pgrp(tsk));
 		spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 		tty->session = get_pid(task_session(tsk));
 		if (tsk->signal->tty) {
 			printk(KERN_DEBUG "tty not NULL!!\n");
 			tty_kref_put(tsk->signal->tty);
 		}
 	}
 	put_pid(tsk->signal->tty_old_pgrp);
 	tsk->signal->tty = tty_kref_get(tty);
 	tsk->signal->tty_old_pgrp = NULL;
 }
 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
 {
 	spin_lock_irq(&tsk->sighand->siglock);
 	__proc_set_tty(tsk, tty);
 	spin_unlock_irq(&tsk->sighand->siglock);
 }
 struct tty_struct *get_current_tty(void)
 {
 	struct tty_struct *tty;
 	unsigned long flags;
 	spin_lock_irqsave(&current->sighand->siglock, flags);
 	tty = tty_kref_get(current->signal->tty);
 	spin_unlock_irqrestore(&current->sighand->siglock, flags);
 	return tty;
 }
 EXPORT_SYMBOL_GPL(get_current_tty);
 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. */
 	tty_ldisc_begin();
 	/*
 	 * 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--)
 		count += sprintf(buf + count, "%s%d%c",
 				 cs[i]->name, cs[i]->index, i ? ' ':'\n');
 	console_unlock();
 	return count;
 }
 static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
 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(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
 			      "console");
 	if (IS_ERR(consdev))
 		consdev = NULL;
 	else
 		WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
 #ifdef CONFIG_VT
 	vty_init(&console_fops);
 #endif
 	return 0;
 }