URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [ftape/] [zftape/] [zftape-ctl.c] - Rev 1765
Compare with Previous | Blame | View Log
/* * Copyright (C) 1996, 1997 Claus-Justus Heine This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. * * $Source: /home/marcus/revision_ctrl_test/oc_cvs/cvs/or1k/linux/linux-2.4/drivers/char/ftape/zftape/zftape-ctl.c,v $ * $Revision: 1.1.1.1 $ * $Date: 2004-04-15 02:02:29 $ * * This file contains the non-read/write zftape functions * for the QIC-40/80/3010/3020 floppy-tape driver for Linux. */ #include <linux/config.h> #include <linux/errno.h> #include <linux/mm.h> #define __NO_VERSION__ #include <linux/module.h> #include <linux/fcntl.h> #include <linux/zftape.h> #if LINUX_VERSION_CODE >= KERNEL_VER(2,1,6) #include <asm/uaccess.h> #else #include <asm/segment.h> #endif #include "../zftape/zftape-init.h" #include "../zftape/zftape-eof.h" #include "../zftape/zftape-ctl.h" #include "../zftape/zftape-write.h" #include "../zftape/zftape-read.h" #include "../zftape/zftape-rw.h" #include "../zftape/zftape-vtbl.h" /* Global vars. */ int zft_write_protected; /* this is when cartridge rdonly or O_RDONLY */ int zft_header_read; int zft_offline; unsigned int zft_unit; int zft_resid; int zft_mt_compression; /* Local vars. */ static int going_offline; typedef int (mt_fun)(int *argptr); typedef int (*mt_funp)(int *argptr); typedef struct { mt_funp function; unsigned offline : 1; /* op permitted if offline or no_tape */ unsigned write_protected : 1; /* op permitted if write-protected */ unsigned not_formatted : 1; /* op permitted if tape not formatted */ unsigned raw_mode : 1; /* op permitted if zft_mode == 0 */ unsigned need_idle_state : 1; /* need to call def_idle_state */ char *name; } fun_entry; static mt_fun mt_dummy, mt_reset, mt_fsr, mt_bsr, mt_rew, mt_offl, mt_nop, mt_weof, mt_erase, mt_ras2, mt_setblk, mt_setdensity, mt_seek, mt_tell, mt_reten, mt_eom, mt_fsf, mt_bsf, mt_fsfm, mt_bsfm, mt_setdrvbuffer, mt_compression; static fun_entry mt_funs[]= { {mt_reset , 1, 1, 1, 1, 0, "MT_RESET" }, /* 0 */ {mt_fsf , 0, 1, 0, 0, 1, "MT_FSF" }, {mt_bsf , 0, 1, 0, 0, 1, "MT_BSF" }, {mt_fsr , 0, 1, 0, 1, 1, "MT_FSR" }, {mt_bsr , 0, 1, 0, 1, 1, "MT_BSR" }, {mt_weof , 0, 0, 0, 0, 0, "MT_WEOF" }, /* 5 */ {mt_rew , 0, 1, 1, 1, 0, "MT_REW" }, {mt_offl , 0, 1, 1, 1, 0, "MT_OFFL" }, {mt_nop , 1, 1, 1, 1, 0, "MT_NOP" }, {mt_reten , 0, 1, 1, 1, 0, "MT_RETEN" }, {mt_bsfm , 0, 1, 0, 0, 1, "MT_BSFM" }, /* 10 */ {mt_fsfm , 0, 1, 0, 0, 1, "MT_FSFM" }, {mt_eom , 0, 1, 0, 0, 1, "MT_EOM" }, {mt_erase , 0, 0, 0, 1, 0, "MT_ERASE" }, {mt_dummy , 1, 1, 1, 1, 0, "MT_RAS1" }, {mt_ras2 , 0, 0, 0, 1, 0, "MT_RAS2" }, {mt_dummy , 1, 1, 1, 1, 0, "MT_RAS3" }, {mt_dummy , 1, 1, 1, 1, 0, "UNKNOWN" }, {mt_dummy , 1, 1, 1, 1, 0, "UNKNOWN" }, {mt_dummy , 1, 1, 1, 1, 0, "UNKNOWN" }, {mt_setblk , 1, 1, 1, 1, 1, "MT_SETBLK"}, /* 20 */ {mt_setdensity , 1, 1, 1, 1, 0, "MT_SETDENSITY"}, {mt_seek , 0, 1, 0, 1, 1, "MT_SEEK" }, {mt_dummy , 0, 1, 0, 1, 1, "MT_TELL" }, /* wr-only ?! */ {mt_setdrvbuffer, 1, 1, 1, 1, 0, "MT_SETDRVBUFFER" }, {mt_dummy , 1, 1, 1, 1, 0, "MT_FSS" }, /* 25 */ {mt_dummy , 1, 1, 1, 1, 0, "MT_BSS" }, {mt_dummy , 1, 1, 1, 1, 0, "MT_WSM" }, {mt_dummy , 1, 1, 1, 1, 0, "MT_LOCK" }, {mt_dummy , 1, 1, 1, 1, 0, "MT_UNLOCK"}, {mt_dummy , 1, 1, 1, 1, 0, "MT_LOAD" }, /* 30 */ {mt_dummy , 1, 1, 1, 1, 0, "MT_UNLOAD"}, {mt_compression , 1, 1, 1, 0, 1, "MT_COMPRESSION"}, {mt_dummy , 1, 1, 1, 1, 0, "MT_SETPART"}, {mt_dummy , 1, 1, 1, 1, 0, "MT_MKPART"} }; #define NR_MT_CMDS NR_ITEMS(mt_funs) void zft_reset_position(zft_position *pos) { TRACE_FUN(ft_t_flow); pos->seg_byte_pos = pos->volume_pos = 0; if (zft_header_read) { /* need to keep track of the volume table and * compression map. We therefor simply * position at the beginning of the first * volume. This covers old ftape archives as * well has various flavours of the * compression map segments. The worst case is * that the compression map shows up as a * additional volume in front of all others. */ pos->seg_pos = zft_find_volume(0)->start_seg; pos->tape_pos = zft_calc_tape_pos(pos->seg_pos); } else { pos->tape_pos = 0; pos->seg_pos = -1; } zft_just_before_eof = 0; zft_deblock_segment = -1; zft_io_state = zft_idle; zft_zap_read_buffers(); zft_prevent_flush(); /* unlock the compresison module if it is loaded. * The zero arg means not to try to load the module. */ if (zft_cmpr_lock(0) == 0) { (*zft_cmpr_ops->reset)(); /* unlock */ } TRACE_EXIT; } static void zft_init_driver(void) { TRACE_FUN(ft_t_flow); zft_resid = zft_header_read = zft_old_ftape = zft_offline = zft_write_protected = going_offline = zft_mt_compression = zft_header_changed = zft_volume_table_changed = zft_written_segments = 0; zft_blk_sz = CONFIG_ZFT_DFLT_BLK_SZ; zft_reset_position(&zft_pos); /* does most of the stuff */ ftape_zap_read_buffers(); ftape_set_state(idle); TRACE_EXIT; } int zft_def_idle_state(void) { int result = 0; TRACE_FUN(ft_t_flow); if (!zft_header_read) { result = zft_read_header_segments(); } else if ((result = zft_flush_buffers()) >= 0 && zft_qic_mode) { /* don't move past eof */ (void)zft_close_volume(&zft_pos); } if (ftape_abort_operation() < 0) { TRACE(ft_t_warn, "ftape_abort_operation() failed"); result = -EIO; } /* clear remaining read buffers */ zft_zap_read_buffers(); zft_io_state = zft_idle; TRACE_EXIT result; } /***************************************************************************** * * * functions for the MTIOCTOP commands * * * *****************************************************************************/ static int mt_dummy(int *dummy) { TRACE_FUN(ft_t_flow); TRACE_EXIT -ENOSYS; } static int mt_reset(int *dummy) { TRACE_FUN(ft_t_flow); (void)ftape_seek_to_bot(); TRACE_CATCH(ftape_reset_drive(), zft_init_driver(); zft_uninit_mem(); zft_offline = 1); /* fake a re-open of the device. This will set all flage and * allocate buffers as appropriate. The new tape condition will * force the open routine to do anything we need. */ TRACE_CATCH(_zft_open(-1 /* fake reopen */, 0 /* dummy */),); TRACE_EXIT 0; } static int mt_fsf(int *arg) { int result; TRACE_FUN(ft_t_flow); result = zft_skip_volumes(*arg, &zft_pos); zft_just_before_eof = 0; TRACE_EXIT result; } static int mt_bsf(int *arg) { int result = 0; TRACE_FUN(ft_t_flow); if (*arg != 0) { result = zft_skip_volumes(-*arg + 1, &zft_pos); } TRACE_EXIT result; } static int seek_block(__s64 data_offset, __s64 block_increment, zft_position *pos) { int result = 0; __s64 new_block_pos; __s64 vol_block_count; const zft_volinfo *volume; int exceed; TRACE_FUN(ft_t_flow); volume = zft_find_volume(pos->seg_pos); if (volume->start_seg == 0 || volume->end_seg == 0) { TRACE_EXIT -EIO; } new_block_pos = (zft_div_blksz(data_offset, volume->blk_sz) + block_increment); vol_block_count = zft_div_blksz(volume->size, volume->blk_sz); if (new_block_pos < 0) { TRACE(ft_t_noise, "new_block_pos " LL_X " < 0", LL(new_block_pos)); zft_resid = (int)new_block_pos; new_block_pos = 0; exceed = 1; } else if (new_block_pos > vol_block_count) { TRACE(ft_t_noise, "new_block_pos " LL_X " exceeds size of volume " LL_X, LL(new_block_pos), LL(vol_block_count)); zft_resid = (int)(vol_block_count - new_block_pos); new_block_pos = vol_block_count; exceed = 1; } else { exceed = 0; } if (zft_use_compression && volume->use_compression) { TRACE_CATCH(zft_cmpr_lock(1 /* try to load */),); result = (*zft_cmpr_ops->seek)(new_block_pos, pos, volume, zft_deblock_buf); pos->tape_pos = zft_calc_tape_pos(pos->seg_pos); pos->tape_pos += pos->seg_byte_pos; } else { pos->volume_pos = zft_mul_blksz(new_block_pos, volume->blk_sz); pos->tape_pos = zft_calc_tape_pos(volume->start_seg); pos->tape_pos += pos->volume_pos; pos->seg_pos = zft_calc_seg_byte_coord(&pos->seg_byte_pos, pos->tape_pos); } zft_just_before_eof = volume->size == pos->volume_pos; if (zft_just_before_eof) { /* why this? because zft_file_no checks agains start * and end segment of a volume. We do not want to * advance to the next volume with this function. */ TRACE(ft_t_noise, "set zft_just_before_eof"); zft_position_before_eof(pos, volume); } TRACE(ft_t_noise, "\n" KERN_INFO "new_seg_pos : %d\n" KERN_INFO "new_tape_pos: " LL_X "\n" KERN_INFO "vol_size : " LL_X "\n" KERN_INFO "seg_byte_pos: %d\n" KERN_INFO "blk_sz : %d", pos->seg_pos, LL(pos->tape_pos), LL(volume->size), pos->seg_byte_pos, volume->blk_sz); if (!exceed) { zft_resid = new_block_pos - zft_div_blksz(pos->volume_pos, volume->blk_sz); } if (zft_resid < 0) { zft_resid = -zft_resid; } TRACE_EXIT ((exceed || zft_resid != 0) && result >= 0) ? -EINVAL : result; } static int mt_fsr(int *arg) { int result; TRACE_FUN(ft_t_flow); result = seek_block(zft_pos.volume_pos, *arg, &zft_pos); TRACE_EXIT result; } static int mt_bsr(int *arg) { int result; TRACE_FUN(ft_t_flow); result = seek_block(zft_pos.volume_pos, -*arg, &zft_pos); TRACE_EXIT result; } static int mt_weof(int *arg) { int result; TRACE_FUN(ft_t_flow); TRACE_CATCH(zft_flush_buffers(),); result = zft_weof(*arg, &zft_pos); TRACE_EXIT result; } static int mt_rew(int *dummy) { int result; TRACE_FUN(ft_t_flow); if(zft_header_read) { (void)zft_def_idle_state(); } result = ftape_seek_to_bot(); zft_reset_position(&zft_pos); TRACE_EXIT result; } static int mt_offl(int *dummy) { int result; TRACE_FUN(ft_t_flow); going_offline= 1; result = mt_rew(NULL); TRACE_EXIT result; } static int mt_nop(int *dummy) { TRACE_FUN(ft_t_flow); /* should we set tape status? */ if (!zft_offline) { /* offline includes no_tape */ (void)zft_def_idle_state(); } TRACE_EXIT 0; } static int mt_reten(int *dummy) { int result; TRACE_FUN(ft_t_flow); if(zft_header_read) { (void)zft_def_idle_state(); } result = ftape_seek_to_eot(); if (result >= 0) { result = ftape_seek_to_bot(); } TRACE_EXIT(result); } static int fsfbsfm(int arg, zft_position *pos) { const zft_volinfo *vtbl; __s64 block_pos; TRACE_FUN(ft_t_flow); /* What to do? This should seek to the next file-mark and * position BEFORE. That is, a next write would just extend * the current file. Well. Let's just seek to the end of the * current file, if count == 1. If count > 1, then do a * "mt_fsf(count - 1)", and then seek to the end of that file. * If count == 0, do nothing */ if (arg == 0) { TRACE_EXIT 0; } zft_just_before_eof = 0; TRACE_CATCH(zft_skip_volumes(arg < 0 ? arg : arg-1, pos), if (arg > 0) { zft_resid ++; }); vtbl = zft_find_volume(pos->seg_pos); block_pos = zft_div_blksz(vtbl->size, vtbl->blk_sz); (void)seek_block(0, block_pos, pos); if (pos->volume_pos != vtbl->size) { zft_just_before_eof = 0; zft_resid = 1; /* we didn't managed to go there */ TRACE_ABORT(-EIO, ft_t_err, "wanted file position " LL_X ", arrived at " LL_X, LL(vtbl->size), LL(pos->volume_pos)); } zft_just_before_eof = 1; TRACE_EXIT 0; } static int mt_bsfm(int *arg) { int result; TRACE_FUN(ft_t_flow); result = fsfbsfm(-*arg, &zft_pos); TRACE_EXIT result; } static int mt_fsfm(int *arg) { int result; TRACE_FUN(ft_t_flow); result = fsfbsfm(*arg, &zft_pos); TRACE_EXIT result; } static int mt_eom(int *dummy) { TRACE_FUN(ft_t_flow); zft_skip_to_eom(&zft_pos); TRACE_EXIT 0; } static int mt_erase(int *dummy) { int result; TRACE_FUN(ft_t_flow); result = zft_erase(); TRACE_EXIT result; } static int mt_ras2(int *dummy) { int result; TRACE_FUN(ft_t_flow); result = -ENOSYS; TRACE_EXIT result; } /* Sets the new blocksize in BYTES * */ static int mt_setblk(int *new_size) { TRACE_FUN(ft_t_flow); if((unsigned int)(*new_size) > ZFT_MAX_BLK_SZ) { TRACE_ABORT(-EINVAL, ft_t_info, "desired blk_sz (%d) should be <= %d bytes", *new_size, ZFT_MAX_BLK_SZ); } if ((*new_size & (FT_SECTOR_SIZE-1)) != 0) { TRACE_ABORT(-EINVAL, ft_t_info, "desired blk_sz (%d) must be a multiple of %d bytes", *new_size, FT_SECTOR_SIZE); } if (*new_size == 0) { if (zft_use_compression) { TRACE_ABORT(-EINVAL, ft_t_info, "Variable block size not yet " "supported with compression"); } *new_size = 1; } zft_blk_sz = *new_size; TRACE_EXIT 0; } static int mt_setdensity(int *arg) { TRACE_FUN(ft_t_flow); SET_TRACE_LEVEL(*arg); TRACE(TRACE_LEVEL, "tracing set to %d", TRACE_LEVEL); if ((int)TRACE_LEVEL != *arg) { TRACE_EXIT -EINVAL; } TRACE_EXIT 0; } static int mt_seek(int *new_block_pos) { int result= 0; TRACE_FUN(ft_t_any); result = seek_block(0, (__s64)*new_block_pos, &zft_pos); TRACE_EXIT result; } /* OK, this is totally different from SCSI, but the worst thing that can * happen is that there is not enough defragmentated memory that can be * allocated. Also, there is a hardwired limit of 16 dma buffers in the * stock ftape module. This shouldn't bring the system down. * * NOTE: the argument specifies the total number of dma buffers to use. * The driver needs at least 3 buffers to function at all. * */ static int mt_setdrvbuffer(int *cnt) { TRACE_FUN(ft_t_flow); if (*cnt < 3) { TRACE_EXIT -EINVAL; } TRACE_CATCH(ftape_set_nr_buffers(*cnt),); TRACE_EXIT 0; } /* return the block position from start of volume */ static int mt_tell(int *arg) { TRACE_FUN(ft_t_flow); *arg = zft_div_blksz(zft_pos.volume_pos, zft_find_volume(zft_pos.seg_pos)->blk_sz); TRACE_EXIT 0; } static int mt_compression(int *arg) { TRACE_FUN(ft_t_flow); /* Ok. We could also check whether compression is available at * all by trying to load the compression module. We could * also check for a block size of 1 byte which is illegal * with compression. Instead of doing it here we rely on * zftape_write() to do the proper checks. */ if ((unsigned int)*arg > 1) { TRACE_EXIT -EINVAL; } if (*arg != 0 && zft_blk_sz == 1) { /* variable block size */ TRACE_ABORT(-EINVAL, ft_t_info, "Compression not yet supported " "with variable block size"); } zft_mt_compression = *arg; if ((zft_unit & ZFT_ZIP_MODE) == 0) { zft_use_compression = zft_mt_compression; } TRACE_EXIT 0; } /* check whether write access is allowed. Write access is denied when * + zft_write_protected == 1 -- this accounts for either hard write * protection of the cartridge or for * O_RDONLY access mode of the tape device * + zft_offline == 1 -- this meany that there is either no tape * or that the MTOFFLINE ioctl has been * previously issued (`soft eject') * + ft_formatted == 0 -- this means that the cartridge is not * formatted * Then we distinuguish two cases. When zft_qic_mode is TRUE, then we try * to emulate a `traditional' (aka SCSI like) UN*X tape device. Therefore we * deny writes when * + zft_qic_mode ==1 && * (!zft_tape_at_lbot() && -- tape no at logical BOT * !(zft_tape_at_eom() || -- tape not at logical EOM (or EOD) * (zft_tape_at_eom() && * zft_old_ftape()))) -- we can't add new volume to tapes * written by old ftape because ftape * don't use the volume table * * when the drive is in true raw mode (aka /dev/rawft0) then we don't * care about LBOT and EOM conditions. This device is intended for a * user level program that wants to truly implement the QIC-80 compliance * at the logical data layout level of the cartridge, i.e. implement all * that volume table and volume directory stuff etc.< */ int zft_check_write_access(zft_position *pos) { TRACE_FUN(ft_t_flow); if (zft_offline) { /* offline includes no_tape */ TRACE_ABORT(-ENXIO, ft_t_info, "tape is offline or no cartridge"); } if (!ft_formatted) { TRACE_ABORT(-EACCES, ft_t_info, "tape is not formatted"); } if (zft_write_protected) { TRACE_ABORT(-EACCES, ft_t_info, "cartridge write protected"); } if (zft_qic_mode) { /* check BOT condition */ if (!zft_tape_at_lbot(pos)) { /* protect cartridges written by old ftape if * not at BOT because they use the vtbl * segment for storing data */ if (zft_old_ftape) { TRACE_ABORT(-EACCES, ft_t_warn, "Cannot write to cartridges written by old ftape when not at BOT"); } /* not at BOT, but allow writes at EOD, of course */ if (!zft_tape_at_eod(pos)) { TRACE_ABORT(-EACCES, ft_t_info, "tape not at BOT and not at EOD"); } } /* fine. Now the tape is either at BOT or at EOD. */ } /* or in raw mode in which case we don't care about BOT and EOD */ TRACE_EXIT 0; } /* decide when we should lock the module in memory, even when calling * the release routine. This really is necessary for use with * kerneld. * * NOTE: we MUST NOT use zft_write_protected, because this includes * the file access mode as well which has no meaning with our * asynchronous update scheme. * * Ugly, ugly. We need to look the module if we changed the block size. * How sad! Need persistent modules storage! * * NOTE: I don't want to lock the module if the number of dma buffers * has been changed. It's enough! Stop the story! Give me persisitent * module storage! Do it! */ int zft_dirty(void) { if (!ft_formatted || zft_offline) { /* cannot be dirty if not formatted or offline */ return 0; } if (zft_blk_sz != CONFIG_ZFT_DFLT_BLK_SZ) { /* blocksize changed, must lock */ return 1; } if (zft_mt_compression != 0) { /* compression mode with /dev/qft, must lock */ return 1; } if (!zft_header_read) { /* tape is logical at BOT, no lock */ return 0; } if (!zft_tape_at_lbot(&zft_pos)) { /* somewhere inside a volume, lock tape */ return 1; } if (zft_volume_table_changed || zft_header_changed) { /* header segments dirty if tape not write protected */ return !(ft_write_protected || zft_old_ftape); } return 0; } /* OPEN routine called by kernel-interface code * * NOTE: this is also called by mt_reset() with dev_minor == -1 * to fake a reopen after a reset. */ int _zft_open(unsigned int dev_minor, unsigned int access_mode) { static unsigned int tape_unit; static unsigned int file_access_mode; int result; TRACE_FUN(ft_t_flow); if ((int)dev_minor == -1) { /* fake reopen */ zft_unit = tape_unit; access_mode = file_access_mode; zft_init_driver(); /* reset all static data to defaults */ } else { tape_unit = dev_minor; file_access_mode = access_mode; if ((result = ftape_enable(FTAPE_SEL(dev_minor))) < 0) { TRACE_ABORT(-ENXIO, ft_t_err, "ftape_enable failed: %d", result); } if (ft_new_tape || ft_no_tape || !ft_formatted || (FTAPE_SEL(zft_unit) != FTAPE_SEL(dev_minor)) || (zft_unit & ZFT_RAW_MODE) != (dev_minor & ZFT_RAW_MODE)) { /* reset all static data to defaults, */ zft_init_driver(); } zft_unit = dev_minor; } zft_set_flags(zft_unit); /* decode the minor bits */ if (zft_blk_sz == 1 && zft_use_compression) { ftape_disable(); /* resets ft_no_tape */ TRACE_ABORT(-ENODEV, ft_t_warn, "Variable block size not yet " "supported with compression"); } /* no need for most of the buffers when no tape or not * formatted. for the read/write operations, it is the * regardless whether there is no tape, a not-formatted tape * or the whether the driver is soft offline. * Nevertheless we allow some ioctls with non-formatted tapes, * like rewind and reset. */ if (ft_no_tape || !ft_formatted) { zft_uninit_mem(); } if (ft_no_tape) { zft_offline = 1; /* so we need not test two variables */ } if ((access_mode == O_WRONLY || access_mode == O_RDWR) && (ft_write_protected || ft_no_tape)) { ftape_disable(); /* resets ft_no_tape */ TRACE_ABORT(ft_no_tape ? -ENXIO : -EROFS, ft_t_warn, "wrong access mode %s cartridge", ft_no_tape ? "without a" : "with write protected"); } zft_write_protected = (access_mode == O_RDONLY || ft_write_protected != 0); if (zft_write_protected) { TRACE(ft_t_noise, "read only access mode: %d, " "drive write protected: %d", access_mode == O_RDONLY, ft_write_protected != 0); } if (!zft_offline) { TRACE_CATCH(zft_vmalloc_once(&zft_deblock_buf,FT_SEGMENT_SIZE), ftape_disable()); } /* zft_seg_pos should be greater than the vtbl segpos but not * if in compatability mode and only after we read in the * header segments * * might also be a problem if the user makes a backup with a * *qft* device and rewinds it with a raw device. */ if (zft_qic_mode && !zft_old_ftape && zft_pos.seg_pos >= 0 && zft_header_read && zft_pos.seg_pos <= ft_first_data_segment) { TRACE(ft_t_noise, "you probably mixed up the zftape devices!"); zft_reset_position(&zft_pos); } TRACE_EXIT 0; } /* RELEASE routine called by kernel-interface code */ int _zft_close(void) { int result = 0; TRACE_FUN(ft_t_flow); if (zft_offline) { /* call the hardware release routine. Puts the drive offline */ ftape_disable(); TRACE_EXIT 0; } if (!(ft_write_protected || zft_old_ftape)) { result = zft_flush_buffers(); TRACE(ft_t_noise, "writing file mark at current position"); if (zft_qic_mode && zft_close_volume(&zft_pos) == 0) { zft_move_past_eof(&zft_pos); } if ((zft_tape_at_lbot(&zft_pos) || !(zft_unit & FTAPE_NO_REWIND))) { if (result >= 0) { result = zft_update_header_segments(); } else { TRACE(ft_t_err, "Error: unable to update header segments"); } } } ftape_abort_operation(); if (!(zft_unit & FTAPE_NO_REWIND)) { TRACE(ft_t_noise, "rewinding tape"); if (ftape_seek_to_bot() < 0 && result >= 0) { result = -EIO; /* keep old value */ } zft_reset_position(&zft_pos); } zft_zap_read_buffers(); /* now free up memory as much as possible. We don't destroy * the deblock buffer if it containes a valid segment. */ if (zft_deblock_segment == -1) { zft_vfree(&zft_deblock_buf, FT_SEGMENT_SIZE); } /* high level driver status, forces creation of a new volume * when calling ftape_write again and not zft_just_before_eof */ zft_io_state = zft_idle; if (going_offline) { zft_init_driver(); zft_uninit_mem(); going_offline = 0; zft_offline = 1; } else if (zft_dirty()) { TRACE(ft_t_noise, "Keeping module locked in memory because:\n" KERN_INFO "header segments need updating: %s\n" KERN_INFO "tape not at BOT : %s", (zft_volume_table_changed || zft_header_changed) ? "yes" : "no", zft_tape_at_lbot(&zft_pos) ? "no" : "yes"); } else if (zft_cmpr_lock(0 /* don't load */) == 0) { (*zft_cmpr_ops->reset)(); /* unlock it again */ } zft_memory_stats(); /* call the hardware release routine. Puts the drive offline */ ftape_disable(); TRACE_EXIT result; } /* * the wrapper function around the wrapper MTIOCTOP ioctl */ static int mtioctop(struct mtop *mtop, int arg_size) { int result = 0; fun_entry *mt_fun_entry; TRACE_FUN(ft_t_flow); if (arg_size != sizeof(struct mtop) || mtop->mt_op >= NR_MT_CMDS) { TRACE_EXIT -EINVAL; } TRACE(ft_t_noise, "calling MTIOCTOP command: %s", mt_funs[mtop->mt_op].name); mt_fun_entry= &mt_funs[mtop->mt_op]; zft_resid = mtop->mt_count; if (!mt_fun_entry->offline && zft_offline) { if (ft_no_tape) { TRACE_ABORT(-ENXIO, ft_t_info, "no tape present"); } else { TRACE_ABORT(-ENXIO, ft_t_info, "drive is offline"); } } if (!mt_fun_entry->not_formatted && !ft_formatted) { TRACE_ABORT(-EACCES, ft_t_info, "tape is not formatted"); } if (!mt_fun_entry->write_protected) { TRACE_CATCH(zft_check_write_access(&zft_pos),); } if (mt_fun_entry->need_idle_state && !(zft_offline || !ft_formatted)) { TRACE_CATCH(zft_def_idle_state(),); } if (!zft_qic_mode && !mt_fun_entry->raw_mode) { TRACE_ABORT(-EACCES, ft_t_info, "Drive needs to be in QIC-80 compatibility mode for this command"); } result = (mt_fun_entry->function)(&mtop->mt_count); if (zft_tape_at_lbot(&zft_pos)) { TRACE_CATCH(zft_update_header_segments(),); } if (result >= 0) { zft_resid = 0; } TRACE_EXIT result; } /* * standard MTIOCGET ioctl */ static int mtiocget(struct mtget *mtget, int arg_size) { const zft_volinfo *volume; __s64 max_tape_pos; TRACE_FUN(ft_t_flow); if (arg_size != sizeof(struct mtget)) { TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d", arg_size); } mtget->mt_type = ft_drive_type.vendor_id + 0x800000; mtget->mt_dsreg = ft_last_status.space; mtget->mt_erreg = ft_last_error.space; /* error register */ mtget->mt_resid = zft_resid; /* residuum of writes, reads and * MTIOCTOP commands */ if (!zft_offline) { /* neither no_tape nor soft offline */ mtget->mt_gstat = GMT_ONLINE(~0UL); /* should rather return the status of the cartridge * than the access mode of the file, therefor use * ft_write_protected, not zft_write_protected */ if (ft_write_protected) { mtget->mt_gstat |= GMT_WR_PROT(~0UL); } if(zft_header_read) { /* this catches non-formatted */ volume = zft_find_volume(zft_pos.seg_pos); mtget->mt_fileno = volume->count; max_tape_pos = zft_capacity - zft_blk_sz; if (zft_use_compression) { max_tape_pos -= ZFT_CMPR_OVERHEAD; } if (zft_tape_at_eod(&zft_pos)) { mtget->mt_gstat |= GMT_EOD(~0UL); } if (zft_pos.tape_pos > max_tape_pos) { mtget->mt_gstat |= GMT_EOT(~0UL); } mtget->mt_blkno = zft_div_blksz(zft_pos.volume_pos, volume->blk_sz); if (zft_just_before_eof) { mtget->mt_gstat |= GMT_EOF(~0UL); } if (zft_tape_at_lbot(&zft_pos)) { mtget->mt_gstat |= GMT_BOT(~0UL); } } else { mtget->mt_fileno = mtget->mt_blkno = -1; if (mtget->mt_dsreg & QIC_STATUS_AT_BOT) { mtget->mt_gstat |= GMT_BOT(~0UL); } } } else { if (ft_no_tape) { mtget->mt_gstat = GMT_DR_OPEN(~0UL); } else { mtget->mt_gstat = 0UL; } mtget->mt_fileno = mtget->mt_blkno = -1; } TRACE_EXIT 0; } #ifdef MTIOCRDFTSEG /* * Read a floppy tape segment. This is useful for manipulating the * volume table, and read the old header segment before re-formatting * the cartridge. */ static int mtiocrdftseg(struct mtftseg * mtftseg, int arg_size) { TRACE_FUN(ft_t_flow); TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCRDFTSEG"); if (zft_qic_mode) { TRACE_ABORT(-EACCES, ft_t_info, "driver needs to be in raw mode for this ioctl"); } if (arg_size != sizeof(struct mtftseg)) { TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d", arg_size); } if (zft_offline) { TRACE_EXIT -ENXIO; } if (mtftseg->mt_mode != FT_RD_SINGLE && mtftseg->mt_mode != FT_RD_AHEAD) { TRACE_ABORT(-EINVAL, ft_t_info, "invalid read mode"); } if (!ft_formatted) { TRACE_EXIT -EACCES; /* -ENXIO ? */ } if (!zft_header_read) { TRACE_CATCH(zft_def_idle_state(),); } if (mtftseg->mt_segno > ft_last_data_segment) { TRACE_ABORT(-EINVAL, ft_t_info, "segment number is too large"); } mtftseg->mt_result = ftape_read_segment(mtftseg->mt_segno, zft_deblock_buf, mtftseg->mt_mode); if (mtftseg->mt_result < 0) { /* a negativ result is not an ioctl error. if * the user wants to read damaged tapes, * it's up to her/him */ TRACE_EXIT 0; } #if LINUX_VERSION_CODE > KERNEL_VER(2,1,3) if (copy_to_user(mtftseg->mt_data, zft_deblock_buf, mtftseg->mt_result) != 0) { TRACE_EXIT -EFAULT; } #else TRACE_CATCH(verify_area(VERIFY_WRITE, mtftseg->mt_data, mtftseg->mt_result),); memcpy_tofs(mtftseg->mt_data, zft_deblock_buf, mtftseg->mt_result); #endif TRACE_EXIT 0; } #endif #ifdef MTIOCWRFTSEG /* * write a floppy tape segment. This version features writing of * deleted address marks, and gracefully ignores the (software) * ft_formatted flag to support writing of header segments after * formatting. */ static int mtiocwrftseg(struct mtftseg * mtftseg, int arg_size) { int result; TRACE_FUN(ft_t_flow); TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCWRFTSEG"); if (zft_write_protected || zft_qic_mode) { TRACE_EXIT -EACCES; } if (arg_size != sizeof(struct mtftseg)) { TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d", arg_size); } if (zft_offline) { TRACE_EXIT -ENXIO; } if (mtftseg->mt_mode != FT_WR_ASYNC && mtftseg->mt_mode != FT_WR_MULTI && mtftseg->mt_mode != FT_WR_SINGLE && mtftseg->mt_mode != FT_WR_DELETE) { TRACE_ABORT(-EINVAL, ft_t_info, "invalid write mode"); } /* * We don't check for ft_formatted, because this gives * only the software status of the driver. * * We assume that the user knows what it is * doing. And rely on the low level stuff to fail * when the tape isn't formatted. We only make sure * that The header segment buffer is allocated, * because it holds the bad sector map. */ if (zft_hseg_buf == NULL) { TRACE_EXIT -ENXIO; } if (mtftseg->mt_mode != FT_WR_DELETE) { #if LINUX_VERSION_CODE > KERNEL_VER(2,1,3) if (copy_from_user(zft_deblock_buf, mtftseg->mt_data, FT_SEGMENT_SIZE) != 0) { TRACE_EXIT -EFAULT; } #else TRACE_CATCH(verify_area(VERIFY_READ, mtftseg->mt_data, FT_SEGMENT_SIZE),); memcpy_fromfs(zft_deblock_buf, mtftseg->mt_data, FT_SEGMENT_SIZE); #endif } mtftseg->mt_result = ftape_write_segment(mtftseg->mt_segno, zft_deblock_buf, mtftseg->mt_mode); if (mtftseg->mt_result >= 0 && mtftseg->mt_mode == FT_WR_SINGLE) { /* * a negativ result is not an ioctl error. if * the user wants to write damaged tapes, * it's up to her/him */ if ((result = ftape_loop_until_writes_done()) < 0) { mtftseg->mt_result = result; } } TRACE_EXIT 0; } #endif #ifdef MTIOCVOLINFO /* * get information about volume positioned at. */ static int mtiocvolinfo(struct mtvolinfo *volinfo, int arg_size) { const zft_volinfo *volume; TRACE_FUN(ft_t_flow); TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCVOLINFO"); if (arg_size != sizeof(struct mtvolinfo)) { TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d", arg_size); } if (zft_offline) { TRACE_EXIT -ENXIO; } if (!ft_formatted) { TRACE_EXIT -EACCES; } TRACE_CATCH(zft_def_idle_state(),); volume = zft_find_volume(zft_pos.seg_pos); volinfo->mt_volno = volume->count; volinfo->mt_blksz = volume->blk_sz == 1 ? 0 : volume->blk_sz; volinfo->mt_size = volume->size >> 10; volinfo->mt_rawsize = ((zft_calc_tape_pos(volume->end_seg + 1) >> 10) - (zft_calc_tape_pos(volume->start_seg) >> 10)); volinfo->mt_cmpr = volume->use_compression; TRACE_EXIT 0; } #endif #ifdef ZFT_OBSOLETE static int mtioc_zftape_getblksz(struct mtblksz *blksz, int arg_size) { TRACE_FUN(ft_t_flow); TRACE(ft_t_noise, "\n" KERN_INFO "Mag tape ioctl command: MTIOC_ZTAPE_GETBLKSZ\n" KERN_INFO "This ioctl is here merely for compatibility.\n" KERN_INFO "Please use MTIOCVOLINFO instead"); if (arg_size != sizeof(struct mtblksz)) { TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d", arg_size); } if (zft_offline) { TRACE_EXIT -ENXIO; } if (!ft_formatted) { TRACE_EXIT -EACCES; } TRACE_CATCH(zft_def_idle_state(),); blksz->mt_blksz = zft_find_volume(zft_pos.seg_pos)->blk_sz; TRACE_EXIT 0; } #endif #ifdef MTIOCGETSIZE /* * get the capacity of the tape cartridge. */ static int mtiocgetsize(struct mttapesize *size, int arg_size) { TRACE_FUN(ft_t_flow); TRACE(ft_t_noise, "Mag tape ioctl command: MTIOC_ZFTAPE_GETSIZE"); if (arg_size != sizeof(struct mttapesize)) { TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d", arg_size); } if (zft_offline) { TRACE_EXIT -ENXIO; } if (!ft_formatted) { TRACE_EXIT -EACCES; } TRACE_CATCH(zft_def_idle_state(),); size->mt_capacity = (unsigned int)(zft_capacity>>10); size->mt_used = (unsigned int)(zft_get_eom_pos()>>10); TRACE_EXIT 0; } #endif static int mtiocpos(struct mtpos *mtpos, int arg_size) { int result; TRACE_FUN(ft_t_flow); TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCPOS"); if (arg_size != sizeof(struct mtpos)) { TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d", arg_size); } result = mt_tell((int *)&mtpos->mt_blkno); TRACE_EXIT result; } #ifdef MTIOCFTFORMAT /* * formatting of floppy tape cartridges. This is intended to be used * together with the MTIOCFTCMD ioctl and the new mmap feature */ /* * This function uses ftape_decode_header_segment() to inform the low * level ftape module about the new parameters. * * It erases the hseg_buf. The calling process must specify all * parameters to assure proper operation. * * return values: -EINVAL - wrong argument size * -EINVAL - if ftape_decode_header_segment() failed. */ static int set_format_parms(struct ftfmtparms *p, __u8 *hseg_buf) { ft_trace_t old_level = TRACE_LEVEL; TRACE_FUN(ft_t_flow); TRACE(ft_t_noise, "MTIOCFTFORMAT operation FTFMT_SETPARMS"); memset(hseg_buf, 0, FT_SEGMENT_SIZE); PUT4(hseg_buf, FT_SIGNATURE, FT_HSEG_MAGIC); /* fill in user specified parameters */ hseg_buf[FT_FMT_CODE] = (__u8)p->ft_fmtcode; PUT2(hseg_buf, FT_SPT, p->ft_spt); hseg_buf[FT_TPC] = (__u8)p->ft_tpc; hseg_buf[FT_FHM] = (__u8)p->ft_fhm; hseg_buf[FT_FTM] = (__u8)p->ft_ftm; /* fill in sane defaults to make ftape happy. */ hseg_buf[FT_FSM] = (__u8)128; /* 128 is hard wired all over ftape */ if (p->ft_fmtcode == fmt_big) { PUT4(hseg_buf, FT_6_HSEG_1, 0); PUT4(hseg_buf, FT_6_HSEG_2, 1); PUT4(hseg_buf, FT_6_FRST_SEG, 2); PUT4(hseg_buf, FT_6_LAST_SEG, p->ft_spt * p->ft_tpc - 1); } else { PUT2(hseg_buf, FT_HSEG_1, 0); PUT2(hseg_buf, FT_HSEG_2, 1); PUT2(hseg_buf, FT_FRST_SEG, 2); PUT2(hseg_buf, FT_LAST_SEG, p->ft_spt * p->ft_tpc - 1); } /* Synchronize with the low level module. This is particularly * needed for unformatted cartridges as the QIC std was previously * unknown BUT is needed to set data rate and to calculate timeouts. */ TRACE_CATCH(ftape_calibrate_data_rate(p->ft_qicstd&QIC_TAPE_STD_MASK), _res = -EINVAL); /* The following will also recalcualte the timeouts for the tape * length and QIC std we want to format to. * abort with -EINVAL rather than -EIO */ SET_TRACE_LEVEL(ft_t_warn); TRACE_CATCH(ftape_decode_header_segment(hseg_buf), SET_TRACE_LEVEL(old_level); _res = -EINVAL); SET_TRACE_LEVEL(old_level); TRACE_EXIT 0; } /* * Return the internal SOFTWARE status of the kernel driver. This does * NOT query the tape drive about its status. */ static int get_format_parms(struct ftfmtparms *p, __u8 *hseg_buffer) { TRACE_FUN(ft_t_flow); TRACE(ft_t_noise, "MTIOCFTFORMAT operation FTFMT_GETPARMS"); p->ft_qicstd = ft_qic_std; p->ft_fmtcode = ft_format_code; p->ft_fhm = hseg_buffer[FT_FHM]; p->ft_ftm = hseg_buffer[FT_FTM]; p->ft_spt = ft_segments_per_track; p->ft_tpc = ft_tracks_per_tape; TRACE_EXIT 0; } static int mtiocftformat(struct mtftformat *mtftformat, int arg_size) { int result; union fmt_arg *arg = &mtftformat->fmt_arg; TRACE_FUN(ft_t_flow); TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCFTFORMAT"); if (zft_offline) { if (ft_no_tape) { TRACE_ABORT(-ENXIO, ft_t_info, "no tape present"); } else { TRACE_ABORT(-ENXIO, ft_t_info, "drive is offline"); } } if (zft_qic_mode) { TRACE_ABORT(-EACCES, ft_t_info, "driver needs to be in raw mode for this ioctl"); } if (zft_hseg_buf == NULL) { TRACE_CATCH(zft_vcalloc_once(&zft_hseg_buf, FT_SEGMENT_SIZE),); } zft_header_read = 0; switch(mtftformat->fmt_op) { case FTFMT_SET_PARMS: TRACE_CATCH(set_format_parms(&arg->fmt_parms, zft_hseg_buf),); TRACE_EXIT 0; case FTFMT_GET_PARMS: TRACE_CATCH(get_format_parms(&arg->fmt_parms, zft_hseg_buf),); TRACE_EXIT 0; case FTFMT_FORMAT_TRACK: if ((ft_formatted && zft_check_write_access(&zft_pos) < 0) || (!ft_formatted && zft_write_protected)) { TRACE_ABORT(-EACCES, ft_t_info, "Write access denied"); } TRACE_CATCH(ftape_format_track(arg->fmt_track.ft_track, arg->fmt_track.ft_gap3),); TRACE_EXIT 0; case FTFMT_STATUS: TRACE_CATCH(ftape_format_status(&arg->fmt_status.ft_segment),); TRACE_EXIT 0; case FTFMT_VERIFY: TRACE_CATCH(ftape_verify_segment(arg->fmt_verify.ft_segment, (SectorMap *)&arg->fmt_verify.ft_bsm),); TRACE_EXIT 0; default: TRACE_ABORT(-EINVAL, ft_t_err, "Invalid format operation"); } TRACE_EXIT result; } #endif #ifdef MTIOCFTCMD /* * send a QIC-117 command to the drive, with optional timeouts, * parameter and result bits. This is intended to be used together * with the formatting ioctl. */ static int mtiocftcmd(struct mtftcmd *ftcmd, int arg_size) { int i; TRACE_FUN(ft_t_flow); TRACE(ft_t_noise, "Mag tape ioctl command: MTIOCFTCMD"); if (!capable(CAP_SYS_ADMIN)) { TRACE_ABORT(-EPERM, ft_t_info, "need CAP_SYS_ADMIN capability to send raw qic-117 commands"); } if (zft_qic_mode) { TRACE_ABORT(-EACCES, ft_t_info, "driver needs to be in raw mode for this ioctl"); } if (arg_size != sizeof(struct mtftcmd)) { TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d", arg_size); } if (ftcmd->ft_wait_before) { TRACE_CATCH(ftape_ready_wait(ftcmd->ft_wait_before, &ftcmd->ft_status),); } if (ftcmd->ft_status & QIC_STATUS_ERROR) goto ftmtcmd_error; if (ftcmd->ft_result_bits != 0) { TRACE_CATCH(ftape_report_operation(&ftcmd->ft_result, ftcmd->ft_cmd, ftcmd->ft_result_bits),); } else { TRACE_CATCH(ftape_command(ftcmd->ft_cmd),); if (ftcmd->ft_status & QIC_STATUS_ERROR) goto ftmtcmd_error; for (i = 0; i < ftcmd->ft_parm_cnt; i++) { TRACE_CATCH(ftape_parameter(ftcmd->ft_parms[i]&0x0f),); if (ftcmd->ft_status & QIC_STATUS_ERROR) goto ftmtcmd_error; } } if (ftcmd->ft_wait_after != 0) { TRACE_CATCH(ftape_ready_wait(ftcmd->ft_wait_after, &ftcmd->ft_status),); } ftmtcmd_error: if (ftcmd->ft_status & QIC_STATUS_ERROR) { TRACE(ft_t_noise, "error status set"); TRACE_CATCH(ftape_report_error(&ftcmd->ft_error, &ftcmd->ft_cmd, 1),); } TRACE_EXIT 0; /* this is not an i/o error */ } #endif /* IOCTL routine called by kernel-interface code */ int _zft_ioctl(unsigned int command, void * arg) { int result; union { struct mtop mtop; struct mtget mtget; struct mtpos mtpos; #ifdef MTIOCRDFTSEG struct mtftseg mtftseg; #endif #ifdef MTIOCVOLINFO struct mtvolinfo mtvolinfo; #endif #ifdef MTIOCGETSIZE struct mttapesize mttapesize; #endif #ifdef MTIOCFTFORMAT struct mtftformat mtftformat; #endif #ifdef ZFT_OBSOLETE struct mtblksz mtblksz; #endif #ifdef MTIOCFTCMD struct mtftcmd mtftcmd; #endif } krnl_arg; int arg_size = _IOC_SIZE(command); int dir = _IOC_DIR(command); TRACE_FUN(ft_t_flow); /* This check will only catch arguments that are too large ! */ if (dir & (_IOC_READ | _IOC_WRITE) && arg_size > sizeof(krnl_arg)) { TRACE_ABORT(-EINVAL, ft_t_info, "bad argument size: %d", arg_size); } if (dir & _IOC_WRITE) { #if LINUX_VERSION_CODE > KERNEL_VER(2,1,3) if (copy_from_user(&krnl_arg, arg, arg_size) != 0) { TRACE_EXIT -EFAULT; } #else TRACE_CATCH(verify_area(VERIFY_READ, arg, arg_size),); memcpy_fromfs(&krnl_arg, arg, arg_size); #endif } TRACE(ft_t_flow, "called with ioctl command: 0x%08x", command); switch (command) { case MTIOCTOP: result = mtioctop(&krnl_arg.mtop, arg_size); break; case MTIOCGET: result = mtiocget(&krnl_arg.mtget, arg_size); break; case MTIOCPOS: result = mtiocpos(&krnl_arg.mtpos, arg_size); break; #ifdef MTIOCVOLINFO case MTIOCVOLINFO: result = mtiocvolinfo(&krnl_arg.mtvolinfo, arg_size); break; #endif #ifdef ZFT_OBSOLETE case MTIOC_ZFTAPE_GETBLKSZ: result = mtioc_zftape_getblksz(&krnl_arg.mtblksz, arg_size); break; #endif #ifdef MTIOCRDFTSEG case MTIOCRDFTSEG: /* read a segment via ioctl */ result = mtiocrdftseg(&krnl_arg.mtftseg, arg_size); break; #endif #ifdef MTIOCWRFTSEG case MTIOCWRFTSEG: /* write a segment via ioctl */ result = mtiocwrftseg(&krnl_arg.mtftseg, arg_size); break; #endif #ifdef MTIOCGETSIZE case MTIOCGETSIZE: result = mtiocgetsize(&krnl_arg.mttapesize, arg_size); break; #endif #ifdef MTIOCFTFORMAT case MTIOCFTFORMAT: result = mtiocftformat(&krnl_arg.mtftformat, arg_size); break; #endif #ifdef MTIOCFTCMD case MTIOCFTCMD: result = mtiocftcmd(&krnl_arg.mtftcmd, arg_size); break; #endif default: result = -EINVAL; break; } if ((result >= 0) && (dir & _IOC_READ)) { #if LINUX_VERSION_CODE > KERNEL_VER(2,1,3) if (copy_to_user(arg, &krnl_arg, arg_size) != 0) { TRACE_EXIT -EFAULT; } #else TRACE_CATCH(verify_area(VERIFY_WRITE, arg, arg_size),); memcpy_tofs(arg, &krnl_arg, arg_size); #endif } TRACE_EXIT result; }