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