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 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 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 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 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 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 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 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 343 __tapechar_ioctl(struct tape_device *device, 344 unsigned int no, unsigned long data) 345 { 346 int rc; 347 348 if (no == MTIOCTOP) { 349 struct mtop op; 350 351 if (copy_from_user(&op, (char __user *) 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 default: 375 ; 376 } 377 rc = tape_mtop(device, op.mt_op, op.mt_count); 378 379 if (op.mt_op == MTWEOF && rc == 0) { 380 if (op.mt_count > device->required_tapemarks) 381 device->required_tapemarks = 0; 382 else 383 device->required_tapemarks -= op.mt_count; 384 } 385 return rc; 386 } 387 if (no == MTIOCPOS) { 388 /* MTIOCPOS: query the tape position. */ 389 struct mtpos pos; 390 391 rc = tape_mtop(device, MTTELL, 1); 392 if (rc < 0) 393 return rc; 394 pos.mt_blkno = rc; 395 if (copy_to_user((char __user *) data, &pos, sizeof(pos)) != 0) 396 return -EFAULT; 397 return 0; 398 } 399 if (no == MTIOCGET) { 400 /* MTIOCGET: query the tape drive status. */ 401 struct mtget get; 402 403 memset(&get, 0, sizeof(get)); 404 get.mt_type = MT_ISUNKNOWN; 405 get.mt_resid = 0 /* device->devstat.rescnt */; 406 get.mt_dsreg = 407 ((device->char_data.block_size << MT_ST_BLKSIZE_SHIFT) 408 & MT_ST_BLKSIZE_MASK); 409 /* FIXME: mt_gstat, mt_erreg, mt_fileno */ 410 get.mt_gstat = 0; 411 get.mt_erreg = 0; 412 get.mt_fileno = 0; 413 get.mt_gstat = device->tape_generic_status; 414 415 if (device->medium_state == MS_LOADED) { 416 rc = tape_mtop(device, MTTELL, 1); 417 418 if (rc < 0) 419 return rc; 420 421 if (rc == 0) 422 get.mt_gstat |= GMT_BOT(~0); 423 424 get.mt_blkno = rc; 425 } 426 427 if (copy_to_user((char __user *) data, &get, sizeof(get)) != 0) 428 return -EFAULT; 429 430 return 0; 431 } 432 /* Try the discipline ioctl function. */ 433 if (device->discipline->ioctl_fn == NULL) 434 return -EINVAL; 435 return device->discipline->ioctl_fn(device, no, data); 436 } 437 438 static long 439 tapechar_ioctl(struct file *filp, unsigned int no, unsigned long data) 440 { 441 struct tape_device *device; 442 long rc; 443 444 DBF_EVENT(6, "TCHAR:ioct\n"); 445 446 device = (struct tape_device *) filp->private_data; 447 mutex_lock(&device->mutex); 448 rc = __tapechar_ioctl(device, no, data); 449 mutex_unlock(&device->mutex); 450 return rc; 451 } 452 453 #ifdef CONFIG_COMPAT 454 static long 455 tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data) 456 { 457 struct tape_device *device = filp->private_data; 458 int rval = -ENOIOCTLCMD; 459 unsigned long argp; 460 461 /* The 'arg' argument of any ioctl function may only be used for 462 * pointers because of the compat pointer conversion. 463 * Consider this when adding new ioctls. 464 */ 465 argp = (unsigned long) compat_ptr(data); 466 if (device->discipline->ioctl_fn) { 467 mutex_lock(&device->mutex); 468 rval = device->discipline->ioctl_fn(device, no, argp); 469 mutex_unlock(&device->mutex); 470 if (rval == -EINVAL) 471 rval = -ENOIOCTLCMD; 472 } 473 474 return rval; 475 } 476 #endif /* CONFIG_COMPAT */ 477 478 /* 479 * Initialize character device frontend. 480 */ 481 int 482 tapechar_init (void) 483 { 484 dev_t dev; 485 486 if (alloc_chrdev_region(&dev, 0, 256, "tape") != 0) 487 return -1; 488 489 tapechar_major = MAJOR(dev); 490 491 return 0; 492 } 493 494 /* 495 * cleanup 496 */ 497 void 498 tapechar_exit(void) 499 { 500 unregister_chrdev_region(MKDEV(tapechar_major, 0), 256); 501 } 502