1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *    character device frontend for tape device driver
4  *
5  *  S390 and zSeries version
6  *    Copyright IBM Corp. 2001, 2006
7  *    Author(s): Carsten Otte <cotte@de.ibm.com>
8  *		 Michael Holzheu <holzheu@de.ibm.com>
9  *		 Tuan Ngo-Anh <ngoanh@de.ibm.com>
10  *		 Martin Schwidefsky <schwidefsky@de.ibm.com>
11  */
12 
13 #define KMSG_COMPONENT "tape"
14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15 
16 #include <linux/module.h>
17 #include <linux/types.h>
18 #include <linux/proc_fs.h>
19 #include <linux/mtio.h>
20 #include <linux/compat.h>
21 
22 #include <linux/uaccess.h>
23 
24 #define TAPE_DBF_AREA	tape_core_dbf
25 
26 #include "tape.h"
27 #include "tape_std.h"
28 #include "tape_class.h"
29 
30 #define TAPECHAR_MAJOR		0	/* get dynamic major */
31 
32 /*
33  * file operation structure for tape character frontend
34  */
35 static ssize_t tapechar_read(struct file *, char __user *, size_t, loff_t *);
36 static ssize_t tapechar_write(struct file *, const char __user *, size_t, loff_t *);
37 static int tapechar_open(struct inode *,struct file *);
38 static int tapechar_release(struct inode *,struct file *);
39 static long tapechar_ioctl(struct file *, unsigned int, unsigned long);
40 #ifdef CONFIG_COMPAT
41 static long tapechar_compat_ioctl(struct file *, unsigned int, unsigned long);
42 #endif
43 
44 static const struct file_operations tape_fops =
45 {
46 	.owner = THIS_MODULE,
47 	.read = tapechar_read,
48 	.write = tapechar_write,
49 	.unlocked_ioctl = tapechar_ioctl,
50 #ifdef CONFIG_COMPAT
51 	.compat_ioctl = tapechar_compat_ioctl,
52 #endif
53 	.open = tapechar_open,
54 	.release = tapechar_release,
55 	.llseek = no_llseek,
56 };
57 
58 static int tapechar_major = TAPECHAR_MAJOR;
59 
60 /*
61  * This function is called for every new tapedevice
62  */
63 int
tapechar_setup_device(struct tape_device * device)64 tapechar_setup_device(struct tape_device * device)
65 {
66 	char	device_name[20];
67 
68 	sprintf(device_name, "ntibm%i", device->first_minor / 2);
69 	device->nt = register_tape_dev(
70 		&device->cdev->dev,
71 		MKDEV(tapechar_major, device->first_minor),
72 		&tape_fops,
73 		device_name,
74 		"non-rewinding"
75 	);
76 	device_name[0] = 'r';
77 	device->rt = register_tape_dev(
78 		&device->cdev->dev,
79 		MKDEV(tapechar_major, device->first_minor + 1),
80 		&tape_fops,
81 		device_name,
82 		"rewinding"
83 	);
84 
85 	return 0;
86 }
87 
88 void
tapechar_cleanup_device(struct tape_device * device)89 tapechar_cleanup_device(struct tape_device *device)
90 {
91 	unregister_tape_dev(&device->cdev->dev, device->rt);
92 	device->rt = NULL;
93 	unregister_tape_dev(&device->cdev->dev, device->nt);
94 	device->nt = NULL;
95 }
96 
97 static int
tapechar_check_idalbuffer(struct tape_device * device,size_t block_size)98 tapechar_check_idalbuffer(struct tape_device *device, size_t block_size)
99 {
100 	struct idal_buffer *new;
101 
102 	if (device->char_data.idal_buf != NULL &&
103 	    device->char_data.idal_buf->size == block_size)
104 		return 0;
105 
106 	if (block_size > MAX_BLOCKSIZE) {
107 		DBF_EVENT(3, "Invalid blocksize (%zd > %d)\n",
108 			block_size, MAX_BLOCKSIZE);
109 		return -EINVAL;
110 	}
111 
112 	/* The current idal buffer is not correct. Allocate a new one. */
113 	new = idal_buffer_alloc(block_size, 0);
114 	if (IS_ERR(new))
115 		return -ENOMEM;
116 
117 	if (device->char_data.idal_buf != NULL)
118 		idal_buffer_free(device->char_data.idal_buf);
119 
120 	device->char_data.idal_buf = new;
121 
122 	return 0;
123 }
124 
125 /*
126  * Tape device read function
127  */
128 static ssize_t
tapechar_read(struct file * filp,char __user * data,size_t count,loff_t * ppos)129 tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos)
130 {
131 	struct tape_device *device;
132 	struct tape_request *request;
133 	size_t block_size;
134 	int rc;
135 
136 	DBF_EVENT(6, "TCHAR:read\n");
137 	device = (struct tape_device *) filp->private_data;
138 
139 	/*
140 	 * If the tape isn't terminated yet, do it now. And since we then
141 	 * are at the end of the tape there wouldn't be anything to read
142 	 * anyways. So we return immediately.
143 	 */
144 	if(device->required_tapemarks) {
145 		return tape_std_terminate_write(device);
146 	}
147 
148 	/* Find out block size to use */
149 	if (device->char_data.block_size != 0) {
150 		if (count < device->char_data.block_size) {
151 			DBF_EVENT(3, "TCHAR:read smaller than block "
152 				  "size was requested\n");
153 			return -EINVAL;
154 		}
155 		block_size = device->char_data.block_size;
156 	} else {
157 		block_size = count;
158 	}
159 
160 	rc = tapechar_check_idalbuffer(device, block_size);
161 	if (rc)
162 		return rc;
163 
164 	DBF_EVENT(6, "TCHAR:nbytes: %lx\n", block_size);
165 	/* Let the discipline build the ccw chain. */
166 	request = device->discipline->read_block(device, block_size);
167 	if (IS_ERR(request))
168 		return PTR_ERR(request);
169 	/* Execute it. */
170 	rc = tape_do_io(device, request);
171 	if (rc == 0) {
172 		rc = block_size - request->rescnt;
173 		DBF_EVENT(6, "TCHAR:rbytes:  %x\n", rc);
174 		/* Copy data from idal buffer to user space. */
175 		if (idal_buffer_to_user(device->char_data.idal_buf,
176 					data, rc) != 0)
177 			rc = -EFAULT;
178 	}
179 	tape_free_request(request);
180 	return rc;
181 }
182 
183 /*
184  * Tape device write function
185  */
186 static ssize_t
tapechar_write(struct file * filp,const char __user * data,size_t count,loff_t * ppos)187 tapechar_write(struct file *filp, const char __user *data, size_t count, loff_t *ppos)
188 {
189 	struct tape_device *device;
190 	struct tape_request *request;
191 	size_t block_size;
192 	size_t written;
193 	int nblocks;
194 	int i, rc;
195 
196 	DBF_EVENT(6, "TCHAR:write\n");
197 	device = (struct tape_device *) filp->private_data;
198 	/* Find out block size and number of blocks */
199 	if (device->char_data.block_size != 0) {
200 		if (count < device->char_data.block_size) {
201 			DBF_EVENT(3, "TCHAR:write smaller than block "
202 				  "size was requested\n");
203 			return -EINVAL;
204 		}
205 		block_size = device->char_data.block_size;
206 		nblocks = count / block_size;
207 	} else {
208 		block_size = count;
209 		nblocks = 1;
210 	}
211 
212 	rc = tapechar_check_idalbuffer(device, block_size);
213 	if (rc)
214 		return rc;
215 
216 	DBF_EVENT(6,"TCHAR:nbytes: %lx\n", block_size);
217 	DBF_EVENT(6, "TCHAR:nblocks: %x\n", nblocks);
218 	/* Let the discipline build the ccw chain. */
219 	request = device->discipline->write_block(device, block_size);
220 	if (IS_ERR(request))
221 		return PTR_ERR(request);
222 	rc = 0;
223 	written = 0;
224 	for (i = 0; i < nblocks; i++) {
225 		/* Copy data from user space to idal buffer. */
226 		if (idal_buffer_from_user(device->char_data.idal_buf,
227 					  data, block_size)) {
228 			rc = -EFAULT;
229 			break;
230 		}
231 		rc = tape_do_io(device, request);
232 		if (rc)
233 			break;
234 		DBF_EVENT(6, "TCHAR:wbytes: %lx\n",
235 			  block_size - request->rescnt);
236 		written += block_size - request->rescnt;
237 		if (request->rescnt != 0)
238 			break;
239 		data += block_size;
240 	}
241 	tape_free_request(request);
242 	if (rc == -ENOSPC) {
243 		/*
244 		 * Ok, the device has no more space. It has NOT written
245 		 * the block.
246 		 */
247 		if (device->discipline->process_eov)
248 			device->discipline->process_eov(device);
249 		if (written > 0)
250 			rc = 0;
251 
252 	}
253 
254 	/*
255 	 * After doing a write we always need two tapemarks to correctly
256 	 * terminate the tape (one to terminate the file, the second to
257 	 * flag the end of recorded data.
258 	 * Since process_eov positions the tape in front of the written
259 	 * tapemark it doesn't hurt to write two marks again.
260 	 */
261 	if (!rc)
262 		device->required_tapemarks = 2;
263 
264 	return rc ? rc : written;
265 }
266 
267 /*
268  * Character frontend tape device open function.
269  */
270 static int
tapechar_open(struct inode * inode,struct file * filp)271 tapechar_open (struct inode *inode, struct file *filp)
272 {
273 	struct tape_device *device;
274 	int minor, rc;
275 
276 	DBF_EVENT(6, "TCHAR:open: %i:%i\n",
277 		imajor(file_inode(filp)),
278 		iminor(file_inode(filp)));
279 
280 	if (imajor(file_inode(filp)) != tapechar_major)
281 		return -ENODEV;
282 
283 	minor = iminor(file_inode(filp));
284 	device = tape_find_device(minor / TAPE_MINORS_PER_DEV);
285 	if (IS_ERR(device)) {
286 		DBF_EVENT(3, "TCHAR:open: tape_find_device() failed\n");
287 		return PTR_ERR(device);
288 	}
289 
290 	rc = tape_open(device);
291 	if (rc == 0) {
292 		filp->private_data = device;
293 		stream_open(inode, filp);
294 	} else
295 		tape_put_device(device);
296 
297 	return rc;
298 }
299 
300 /*
301  * Character frontend tape device release function.
302  */
303 
304 static int
tapechar_release(struct inode * inode,struct file * filp)305 tapechar_release(struct inode *inode, struct file *filp)
306 {
307 	struct tape_device *device;
308 
309 	DBF_EVENT(6, "TCHAR:release: %x\n", iminor(inode));
310 	device = (struct tape_device *) filp->private_data;
311 
312 	/*
313 	 * If this is the rewinding tape minor then rewind. In that case we
314 	 * write all required tapemarks. Otherwise only one to terminate the
315 	 * file.
316 	 */
317 	if ((iminor(inode) & 1) != 0) {
318 		if (device->required_tapemarks)
319 			tape_std_terminate_write(device);
320 		tape_mtop(device, MTREW, 1);
321 	} else {
322 		if (device->required_tapemarks > 1) {
323 			if (tape_mtop(device, MTWEOF, 1) == 0)
324 				device->required_tapemarks--;
325 		}
326 	}
327 
328 	if (device->char_data.idal_buf != NULL) {
329 		idal_buffer_free(device->char_data.idal_buf);
330 		device->char_data.idal_buf = NULL;
331 	}
332 	tape_release(device);
333 	filp->private_data = NULL;
334 	tape_put_device(device);
335 
336 	return 0;
337 }
338 
339 /*
340  * Tape device io controls.
341  */
342 static int
__tapechar_ioctl(struct tape_device * device,unsigned int no,void __user * data)343 __tapechar_ioctl(struct tape_device *device,
344 		 unsigned int no, void __user *data)
345 {
346 	int rc;
347 
348 	if (no == MTIOCTOP) {
349 		struct mtop op;
350 
351 		if (copy_from_user(&op, data, sizeof(op)) != 0)
352 			return -EFAULT;
353 		if (op.mt_count < 0)
354 			return -EINVAL;
355 
356 		/*
357 		 * Operations that change tape position should write final
358 		 * tapemarks.
359 		 */
360 		switch (op.mt_op) {
361 			case MTFSF:
362 			case MTBSF:
363 			case MTFSR:
364 			case MTBSR:
365 			case MTREW:
366 			case MTOFFL:
367 			case MTEOM:
368 			case MTRETEN:
369 			case MTBSFM:
370 			case MTFSFM:
371 			case MTSEEK:
372 				if (device->required_tapemarks)
373 					tape_std_terminate_write(device);
374 		}
375 		rc = tape_mtop(device, op.mt_op, op.mt_count);
376 
377 		if (op.mt_op == MTWEOF && rc == 0) {
378 			if (op.mt_count > device->required_tapemarks)
379 				device->required_tapemarks = 0;
380 			else
381 				device->required_tapemarks -= op.mt_count;
382 		}
383 		return rc;
384 	}
385 	if (no == MTIOCPOS) {
386 		/* MTIOCPOS: query the tape position. */
387 		struct mtpos pos;
388 
389 		rc = tape_mtop(device, MTTELL, 1);
390 		if (rc < 0)
391 			return rc;
392 		pos.mt_blkno = rc;
393 		return put_user_mtpos(data, &pos);
394 	}
395 	if (no == MTIOCGET) {
396 		/* MTIOCGET: query the tape drive status. */
397 		struct mtget get;
398 
399 		memset(&get, 0, sizeof(get));
400 		get.mt_type = MT_ISUNKNOWN;
401 		get.mt_resid = 0 /* device->devstat.rescnt */;
402 		get.mt_dsreg =
403 			((device->char_data.block_size << MT_ST_BLKSIZE_SHIFT)
404 			 & MT_ST_BLKSIZE_MASK);
405 		/* FIXME: mt_gstat, mt_erreg, mt_fileno */
406 		get.mt_gstat = 0;
407 		get.mt_erreg = 0;
408 		get.mt_fileno = 0;
409 		get.mt_gstat  = device->tape_generic_status;
410 
411 		if (device->medium_state == MS_LOADED) {
412 			rc = tape_mtop(device, MTTELL, 1);
413 
414 			if (rc < 0)
415 				return rc;
416 
417 			if (rc == 0)
418 				get.mt_gstat |= GMT_BOT(~0);
419 
420 			get.mt_blkno = rc;
421 		}
422 
423 		return put_user_mtget(data, &get);
424 	}
425 	/* Try the discipline ioctl function. */
426 	if (device->discipline->ioctl_fn == NULL)
427 		return -EINVAL;
428 	return device->discipline->ioctl_fn(device, no, (unsigned long)data);
429 }
430 
431 static long
tapechar_ioctl(struct file * filp,unsigned int no,unsigned long data)432 tapechar_ioctl(struct file *filp, unsigned int no, unsigned long data)
433 {
434 	struct tape_device *device;
435 	long rc;
436 
437 	DBF_EVENT(6, "TCHAR:ioct\n");
438 
439 	device = (struct tape_device *) filp->private_data;
440 	mutex_lock(&device->mutex);
441 	rc = __tapechar_ioctl(device, no, (void __user *)data);
442 	mutex_unlock(&device->mutex);
443 	return rc;
444 }
445 
446 #ifdef CONFIG_COMPAT
447 static long
tapechar_compat_ioctl(struct file * filp,unsigned int no,unsigned long data)448 tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data)
449 {
450 	struct tape_device *device = filp->private_data;
451 	long rc;
452 
453 	if (no == MTIOCPOS32)
454 		no = MTIOCPOS;
455 	else if (no == MTIOCGET32)
456 		no = MTIOCGET;
457 
458 	mutex_lock(&device->mutex);
459 	rc = __tapechar_ioctl(device, no, compat_ptr(data));
460 	mutex_unlock(&device->mutex);
461 	return rc;
462 }
463 #endif /* CONFIG_COMPAT */
464 
465 /*
466  * Initialize character device frontend.
467  */
468 int
tapechar_init(void)469 tapechar_init (void)
470 {
471 	dev_t	dev;
472 
473 	if (alloc_chrdev_region(&dev, 0, 256, "tape") != 0)
474 		return -1;
475 
476 	tapechar_major = MAJOR(dev);
477 
478 	return 0;
479 }
480 
481 /*
482  * cleanup
483  */
484 void
tapechar_exit(void)485 tapechar_exit(void)
486 {
487 	unregister_chrdev_region(MKDEV(tapechar_major, 0), 256);
488 }
489