URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [ftape/] [zftape/] [zftape-ctl.c] - Blame information for rev 1765

Details | Compare with Previous | 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;
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [ftape/] [zftape/] [zftape-ctl.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* Copyright (C) 1996, 1997 Claus-Justus Heine`
3
4			`This program is free software; you can redistribute it and/or modify`
5			`it under the terms of the GNU General Public License as published by`
6			`the Free Software Foundation; either version 2, or (at your option)`
7			`any later version.`
8
9			`This program is distributed in the hope that it will be useful,`
10			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
11			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
12			`GNU General Public License for more details.`
13
14			`You should have received a copy of the GNU General Public License`
15			`along with this program; see the file COPYING. If not, write to`
16			`the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.`
17
18			`*`
19			`* $Source: /home/marcus/revision_ctrl_test/oc_cvs/cvs/or1k/linux/linux-2.4/drivers/char/ftape/zftape/zftape-ctl.c,v $`
20			`* $Revision: 1.1.1.1 $`
21			`* $Date: 2004-04-15 02:02:29 $`
22			`*`
23			`* This file contains the non-read/write zftape functions`
24			`* for the QIC-40/80/3010/3020 floppy-tape driver for Linux.`
25			`*/`
26
27			`#include <linux/config.h>`
28			`#include <linux/errno.h>`
29			`#include <linux/mm.h>`
30			`#define __NO_VERSION__`
31			`#include <linux/module.h>`
32			`#include <linux/fcntl.h>`
33
34			`#include <linux/zftape.h>`
35
36			`#if LINUX_VERSION_CODE >= KERNEL_VER(2,1,6)`
37			`#include <asm/uaccess.h>`
38			`#else`
39			`#include <asm/segment.h>`
40			`#endif`