7850c6ae06e4705e0717e9b9875044035418ef81
[linux-3.10.git] / drivers / target / target_core_file.c
1 /*******************************************************************************
2  * Filename:  target_core_file.c
3  *
4  * This file contains the Storage Engine <-> FILEIO transport specific functions
5  *
6  * Copyright (c) 2005 PyX Technologies, Inc.
7  * Copyright (c) 2005-2006 SBE, Inc.  All Rights Reserved.
8  * Copyright (c) 2007-2010 Rising Tide Systems
9  * Copyright (c) 2008-2010 Linux-iSCSI.org
10  *
11  * Nicholas A. Bellinger <nab@kernel.org>
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26  *
27  ******************************************************************************/
28
29 #include <linux/version.h>
30 #include <linux/string.h>
31 #include <linux/parser.h>
32 #include <linux/timer.h>
33 #include <linux/blkdev.h>
34 #include <linux/slab.h>
35 #include <linux/spinlock.h>
36 #include <scsi/scsi.h>
37 #include <scsi/scsi_host.h>
38
39 #include <target/target_core_base.h>
40 #include <target/target_core_device.h>
41 #include <target/target_core_transport.h>
42
43 #include "target_core_file.h"
44
45 #if 1
46 #define DEBUG_FD_CACHE(x...) printk(x)
47 #else
48 #define DEBUG_FD_CACHE(x...)
49 #endif
50
51 #if 1
52 #define DEBUG_FD_FUA(x...) printk(x)
53 #else
54 #define DEBUG_FD_FUA(x...)
55 #endif
56
57 static struct se_subsystem_api fileio_template;
58
59 /*      fd_attach_hba(): (Part of se_subsystem_api_t template)
60  *
61  *
62  */
63 static int fd_attach_hba(struct se_hba *hba, u32 host_id)
64 {
65         struct fd_host *fd_host;
66
67         fd_host = kzalloc(sizeof(struct fd_host), GFP_KERNEL);
68         if (!(fd_host)) {
69                 printk(KERN_ERR "Unable to allocate memory for struct fd_host\n");
70                 return -1;
71         }
72
73         fd_host->fd_host_id = host_id;
74
75         atomic_set(&hba->left_queue_depth, FD_HBA_QUEUE_DEPTH);
76         atomic_set(&hba->max_queue_depth, FD_HBA_QUEUE_DEPTH);
77         hba->hba_ptr = (void *) fd_host;
78
79         printk(KERN_INFO "CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
80                 " Target Core Stack %s\n", hba->hba_id, FD_VERSION,
81                 TARGET_CORE_MOD_VERSION);
82         printk(KERN_INFO "CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic"
83                 " Target Core with TCQ Depth: %d MaxSectors: %u\n",
84                 hba->hba_id, fd_host->fd_host_id,
85                 atomic_read(&hba->max_queue_depth), FD_MAX_SECTORS);
86
87         return 0;
88 }
89
90 static void fd_detach_hba(struct se_hba *hba)
91 {
92         struct fd_host *fd_host = hba->hba_ptr;
93
94         printk(KERN_INFO "CORE_HBA[%d] - Detached FILEIO HBA: %u from Generic"
95                 " Target Core\n", hba->hba_id, fd_host->fd_host_id);
96
97         kfree(fd_host);
98         hba->hba_ptr = NULL;
99 }
100
101 static void *fd_allocate_virtdevice(struct se_hba *hba, const char *name)
102 {
103         struct fd_dev *fd_dev;
104         struct fd_host *fd_host = (struct fd_host *) hba->hba_ptr;
105
106         fd_dev = kzalloc(sizeof(struct fd_dev), GFP_KERNEL);
107         if (!(fd_dev)) {
108                 printk(KERN_ERR "Unable to allocate memory for struct fd_dev\n");
109                 return NULL;
110         }
111
112         fd_dev->fd_host = fd_host;
113
114         printk(KERN_INFO "FILEIO: Allocated fd_dev for %p\n", name);
115
116         return fd_dev;
117 }
118
119 /*      fd_create_virtdevice(): (Part of se_subsystem_api_t template)
120  *
121  *
122  */
123 static struct se_device *fd_create_virtdevice(
124         struct se_hba *hba,
125         struct se_subsystem_dev *se_dev,
126         void *p)
127 {
128         char *dev_p = NULL;
129         struct se_device *dev;
130         struct se_dev_limits dev_limits;
131         struct queue_limits *limits;
132         struct fd_dev *fd_dev = (struct fd_dev *) p;
133         struct fd_host *fd_host = (struct fd_host *) hba->hba_ptr;
134         mm_segment_t old_fs;
135         struct file *file;
136         struct inode *inode = NULL;
137         int dev_flags = 0, flags;
138
139         memset(&dev_limits, 0, sizeof(struct se_dev_limits));
140
141         old_fs = get_fs();
142         set_fs(get_ds());
143         dev_p = getname(fd_dev->fd_dev_name);
144         set_fs(old_fs);
145
146         if (IS_ERR(dev_p)) {
147                 printk(KERN_ERR "getname(%s) failed: %lu\n",
148                         fd_dev->fd_dev_name, IS_ERR(dev_p));
149                 goto fail;
150         }
151 #if 0
152         if (di->no_create_file)
153                 flags = O_RDWR | O_LARGEFILE;
154         else
155                 flags = O_RDWR | O_CREAT | O_LARGEFILE;
156 #else
157         flags = O_RDWR | O_CREAT | O_LARGEFILE;
158 #endif
159 /*      flags |= O_DIRECT; */
160         /*
161          * If fd_buffered_io=1 has not been set explictly (the default),
162          * use O_SYNC to force FILEIO writes to disk.
163          */
164         if (!(fd_dev->fbd_flags & FDBD_USE_BUFFERED_IO))
165                 flags |= O_SYNC;
166
167         file = filp_open(dev_p, flags, 0600);
168
169         if (IS_ERR(file) || !file || !file->f_dentry) {
170                 printk(KERN_ERR "filp_open(%s) failed\n", dev_p);
171                 goto fail;
172         }
173         fd_dev->fd_file = file;
174         /*
175          * If using a block backend with this struct file, we extract
176          * fd_dev->fd_[block,dev]_size from struct block_device.
177          *
178          * Otherwise, we use the passed fd_size= from configfs
179          */
180         inode = file->f_mapping->host;
181         if (S_ISBLK(inode->i_mode)) {
182                 struct request_queue *q;
183                 /*
184                  * Setup the local scope queue_limits from struct request_queue->limits
185                  * to pass into transport_add_device_to_core_hba() as struct se_dev_limits.
186                  */
187                 q = bdev_get_queue(inode->i_bdev);
188                 limits = &dev_limits.limits;
189                 limits->logical_block_size = bdev_logical_block_size(inode->i_bdev);
190                 limits->max_hw_sectors = queue_max_hw_sectors(q);
191                 limits->max_sectors = queue_max_sectors(q);
192                 /*
193                  * Determine the number of bytes from i_size_read() minus
194                  * one (1) logical sector from underlying struct block_device
195                  */
196                 fd_dev->fd_block_size = bdev_logical_block_size(inode->i_bdev);
197                 fd_dev->fd_dev_size = (i_size_read(file->f_mapping->host) -
198                                        fd_dev->fd_block_size);
199
200                 printk(KERN_INFO "FILEIO: Using size: %llu bytes from struct"
201                         " block_device blocks: %llu logical_block_size: %d\n",
202                         fd_dev->fd_dev_size,
203                         div_u64(fd_dev->fd_dev_size, fd_dev->fd_block_size),
204                         fd_dev->fd_block_size);
205         } else {
206                 if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) {
207                         printk(KERN_ERR "FILEIO: Missing fd_dev_size="
208                                 " parameter, and no backing struct"
209                                 " block_device\n");
210                         goto fail;
211                 }
212
213                 limits = &dev_limits.limits;
214                 limits->logical_block_size = FD_BLOCKSIZE;
215                 limits->max_hw_sectors = FD_MAX_SECTORS;
216                 limits->max_sectors = FD_MAX_SECTORS;
217                 fd_dev->fd_block_size = FD_BLOCKSIZE;
218         }
219
220         dev_limits.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH;
221         dev_limits.queue_depth = FD_DEVICE_QUEUE_DEPTH;
222
223         dev = transport_add_device_to_core_hba(hba, &fileio_template,
224                                 se_dev, dev_flags, (void *)fd_dev,
225                                 &dev_limits, "FILEIO", FD_VERSION);
226         if (!(dev))
227                 goto fail;
228
229         fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
230         fd_dev->fd_queue_depth = dev->queue_depth;
231
232         printk(KERN_INFO "CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"
233                 " %llu total bytes\n", fd_host->fd_host_id, fd_dev->fd_dev_id,
234                         fd_dev->fd_dev_name, fd_dev->fd_dev_size);
235
236         putname(dev_p);
237         return dev;
238 fail:
239         if (fd_dev->fd_file) {
240                 filp_close(fd_dev->fd_file, NULL);
241                 fd_dev->fd_file = NULL;
242         }
243         putname(dev_p);
244         return NULL;
245 }
246
247 /*      fd_free_device(): (Part of se_subsystem_api_t template)
248  *
249  *
250  */
251 static void fd_free_device(void *p)
252 {
253         struct fd_dev *fd_dev = (struct fd_dev *) p;
254
255         if (fd_dev->fd_file) {
256                 filp_close(fd_dev->fd_file, NULL);
257                 fd_dev->fd_file = NULL;
258         }
259
260         kfree(fd_dev);
261 }
262
263 static inline struct fd_request *FILE_REQ(struct se_task *task)
264 {
265         return container_of(task, struct fd_request, fd_task);
266 }
267
268
269 static struct se_task *
270 fd_alloc_task(struct se_cmd *cmd)
271 {
272         struct fd_request *fd_req;
273
274         fd_req = kzalloc(sizeof(struct fd_request), GFP_KERNEL);
275         if (!(fd_req)) {
276                 printk(KERN_ERR "Unable to allocate struct fd_request\n");
277                 return NULL;
278         }
279
280         fd_req->fd_dev = SE_DEV(cmd)->dev_ptr;
281
282         return &fd_req->fd_task;
283 }
284
285 static int fd_do_readv(struct se_task *task)
286 {
287         struct fd_request *req = FILE_REQ(task);
288         struct file *fd = req->fd_dev->fd_file;
289         struct scatterlist *sg = task->task_sg;
290         struct iovec *iov;
291         mm_segment_t old_fs;
292         loff_t pos = (task->task_lba * DEV_ATTRIB(task->se_dev)->block_size);
293         int ret = 0, i;
294
295         iov = kzalloc(sizeof(struct iovec) * task->task_sg_num, GFP_KERNEL);
296         if (!(iov)) {
297                 printk(KERN_ERR "Unable to allocate fd_do_readv iov[]\n");
298                 return -1;
299         }
300
301         for (i = 0; i < task->task_sg_num; i++) {
302                 iov[i].iov_len = sg[i].length;
303                 iov[i].iov_base = sg_virt(&sg[i]);
304         }
305
306         old_fs = get_fs();
307         set_fs(get_ds());
308         ret = vfs_readv(fd, &iov[0], task->task_sg_num, &pos);
309         set_fs(old_fs);
310
311         kfree(iov);
312         /*
313          * Return zeros and GOOD status even if the READ did not return
314          * the expected virt_size for struct file w/o a backing struct
315          * block_device.
316          */
317         if (S_ISBLK(fd->f_dentry->d_inode->i_mode)) {
318                 if (ret < 0 || ret != task->task_size) {
319                         printk(KERN_ERR "vfs_readv() returned %d,"
320                                 " expecting %d for S_ISBLK\n", ret,
321                                 (int)task->task_size);
322                         return -1;
323                 }
324         } else {
325                 if (ret < 0) {
326                         printk(KERN_ERR "vfs_readv() returned %d for non"
327                                 " S_ISBLK\n", ret);
328                         return -1;
329                 }
330         }
331
332         return 1;
333 }
334
335 static int fd_do_writev(struct se_task *task)
336 {
337         struct fd_request *req = FILE_REQ(task);
338         struct file *fd = req->fd_dev->fd_file;
339         struct scatterlist *sg = task->task_sg;
340         struct iovec *iov;
341         mm_segment_t old_fs;
342         loff_t pos = (task->task_lba * DEV_ATTRIB(task->se_dev)->block_size);
343         int ret, i = 0;
344
345         iov = kzalloc(sizeof(struct iovec) * task->task_sg_num, GFP_KERNEL);
346         if (!(iov)) {
347                 printk(KERN_ERR "Unable to allocate fd_do_writev iov[]\n");
348                 return -1;
349         }
350
351         for (i = 0; i < task->task_sg_num; i++) {
352                 iov[i].iov_len = sg[i].length;
353                 iov[i].iov_base = sg_virt(&sg[i]);
354         }
355
356         old_fs = get_fs();
357         set_fs(get_ds());
358         ret = vfs_writev(fd, &iov[0], task->task_sg_num, &pos);
359         set_fs(old_fs);
360
361         kfree(iov);
362
363         if (ret < 0 || ret != task->task_size) {
364                 printk(KERN_ERR "vfs_writev() returned %d\n", ret);
365                 return -1;
366         }
367
368         return 1;
369 }
370
371 static void fd_emulate_sync_cache(struct se_task *task)
372 {
373         struct se_cmd *cmd = TASK_CMD(task);
374         struct se_device *dev = cmd->se_dev;
375         struct fd_dev *fd_dev = dev->dev_ptr;
376         int immed = (cmd->t_task->t_task_cdb[1] & 0x2);
377         loff_t start, end;
378         int ret;
379
380         /*
381          * If the Immediate bit is set, queue up the GOOD response
382          * for this SYNCHRONIZE_CACHE op
383          */
384         if (immed)
385                 transport_complete_sync_cache(cmd, 1);
386
387         /*
388          * Determine if we will be flushing the entire device.
389          */
390         if (cmd->t_task->t_task_lba == 0 && cmd->data_length == 0) {
391                 start = 0;
392                 end = LLONG_MAX;
393         } else {
394                 start = cmd->t_task->t_task_lba * DEV_ATTRIB(dev)->block_size;
395                 if (cmd->data_length)
396                         end = start + cmd->data_length;
397                 else
398                         end = LLONG_MAX;
399         }
400
401         ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
402         if (ret != 0)
403                 printk(KERN_ERR "FILEIO: vfs_fsync_range() failed: %d\n", ret);
404
405         if (!immed)
406                 transport_complete_sync_cache(cmd, ret == 0);
407 }
408
409 /*
410  * Tell TCM Core that we are capable of WriteCache emulation for
411  * an underlying struct se_device.
412  */
413 static int fd_emulated_write_cache(struct se_device *dev)
414 {
415         return 1;
416 }
417
418 static int fd_emulated_dpo(struct se_device *dev)
419 {
420         return 0;
421 }
422 /*
423  * Tell TCM Core that we will be emulating Forced Unit Access (FUA) for WRITEs
424  * for TYPE_DISK.
425  */
426 static int fd_emulated_fua_write(struct se_device *dev)
427 {
428         return 1;
429 }
430
431 static int fd_emulated_fua_read(struct se_device *dev)
432 {
433         return 0;
434 }
435
436 /*
437  * WRITE Force Unit Access (FUA) emulation on a per struct se_task
438  * LBA range basis..
439  */
440 static void fd_emulate_write_fua(struct se_cmd *cmd, struct se_task *task)
441 {
442         struct se_device *dev = cmd->se_dev;
443         struct fd_dev *fd_dev = dev->dev_ptr;
444         loff_t start = task->task_lba * DEV_ATTRIB(dev)->block_size;
445         loff_t end = start + task->task_size;
446         int ret;
447
448         DEBUG_FD_CACHE("FILEIO: FUA WRITE LBA: %llu, bytes: %u\n",
449                         task->task_lba, task->task_size);
450
451         ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
452         if (ret != 0)
453                 printk(KERN_ERR "FILEIO: vfs_fsync_range() failed: %d\n", ret);
454 }
455
456 static int fd_do_task(struct se_task *task)
457 {
458         struct se_cmd *cmd = task->task_se_cmd;
459         struct se_device *dev = cmd->se_dev;
460         int ret = 0;
461
462         /*
463          * Call vectorized fileio functions to map struct scatterlist
464          * physical memory addresses to struct iovec virtual memory.
465          */
466         if (task->task_data_direction == DMA_FROM_DEVICE) {
467                 ret = fd_do_readv(task);
468         } else {
469                 ret = fd_do_writev(task);
470
471                 if (ret > 0 &&
472                     DEV_ATTRIB(dev)->emulate_write_cache > 0 &&
473                     DEV_ATTRIB(dev)->emulate_fua_write > 0 &&
474                     T_TASK(cmd)->t_tasks_fua) {
475                         /*
476                          * We might need to be a bit smarter here
477                          * and return some sense data to let the initiator
478                          * know the FUA WRITE cache sync failed..?
479                          */
480                         fd_emulate_write_fua(cmd, task);
481                 }
482
483         }
484
485         if (ret < 0)
486                 return ret;
487         if (ret) {
488                 task->task_scsi_status = GOOD;
489                 transport_complete_task(task, 1);
490         }
491         return PYX_TRANSPORT_SENT_TO_TRANSPORT;
492 }
493
494 /*      fd_free_task(): (Part of se_subsystem_api_t template)
495  *
496  *
497  */
498 static void fd_free_task(struct se_task *task)
499 {
500         struct fd_request *req = FILE_REQ(task);
501
502         kfree(req);
503 }
504
505 enum {
506         Opt_fd_dev_name, Opt_fd_dev_size, Opt_fd_buffered_io, Opt_err
507 };
508
509 static match_table_t tokens = {
510         {Opt_fd_dev_name, "fd_dev_name=%s"},
511         {Opt_fd_dev_size, "fd_dev_size=%s"},
512         {Opt_fd_buffered_io, "fd_buffered_id=%d"},
513         {Opt_err, NULL}
514 };
515
516 static ssize_t fd_set_configfs_dev_params(
517         struct se_hba *hba,
518         struct se_subsystem_dev *se_dev,
519         const char *page, ssize_t count)
520 {
521         struct fd_dev *fd_dev = se_dev->se_dev_su_ptr;
522         char *orig, *ptr, *arg_p, *opts;
523         substring_t args[MAX_OPT_ARGS];
524         int ret = 0, arg, token;
525
526         opts = kstrdup(page, GFP_KERNEL);
527         if (!opts)
528                 return -ENOMEM;
529
530         orig = opts;
531
532         while ((ptr = strsep(&opts, ",")) != NULL) {
533                 if (!*ptr)
534                         continue;
535
536                 token = match_token(ptr, tokens, args);
537                 switch (token) {
538                 case Opt_fd_dev_name:
539                         arg_p = match_strdup(&args[0]);
540                         if (!arg_p) {
541                                 ret = -ENOMEM;
542                                 break;
543                         }
544                         snprintf(fd_dev->fd_dev_name, FD_MAX_DEV_NAME,
545                                         "%s", arg_p);
546                         kfree(arg_p);
547                         printk(KERN_INFO "FILEIO: Referencing Path: %s\n",
548                                         fd_dev->fd_dev_name);
549                         fd_dev->fbd_flags |= FBDF_HAS_PATH;
550                         break;
551                 case Opt_fd_dev_size:
552                         arg_p = match_strdup(&args[0]);
553                         if (!arg_p) {
554                                 ret = -ENOMEM;
555                                 break;
556                         }
557                         ret = strict_strtoull(arg_p, 0, &fd_dev->fd_dev_size);
558                         kfree(arg_p);
559                         if (ret < 0) {
560                                 printk(KERN_ERR "strict_strtoull() failed for"
561                                                 " fd_dev_size=\n");
562                                 goto out;
563                         }
564                         printk(KERN_INFO "FILEIO: Referencing Size: %llu"
565                                         " bytes\n", fd_dev->fd_dev_size);
566                         fd_dev->fbd_flags |= FBDF_HAS_SIZE;
567                         break;
568                 case Opt_fd_buffered_io:
569                         match_int(args, &arg);
570                         if (arg != 1) {
571                                 printk(KERN_ERR "bogus fd_buffered_io=%d value\n", arg);
572                                 ret = -EINVAL;
573                                 goto out;
574                         }
575
576                         printk(KERN_INFO "FILEIO: Using buffered I/O"
577                                 " operations for struct fd_dev\n");
578
579                         fd_dev->fbd_flags |= FDBD_USE_BUFFERED_IO;
580                         break;
581                 default:
582                         break;
583                 }
584         }
585
586 out:
587         kfree(orig);
588         return (!ret) ? count : ret;
589 }
590
591 static ssize_t fd_check_configfs_dev_params(struct se_hba *hba, struct se_subsystem_dev *se_dev)
592 {
593         struct fd_dev *fd_dev = (struct fd_dev *) se_dev->se_dev_su_ptr;
594
595         if (!(fd_dev->fbd_flags & FBDF_HAS_PATH)) {
596                 printk(KERN_ERR "Missing fd_dev_name=\n");
597                 return -1;
598         }
599
600         return 0;
601 }
602
603 static ssize_t fd_show_configfs_dev_params(
604         struct se_hba *hba,
605         struct se_subsystem_dev *se_dev,
606         char *b)
607 {
608         struct fd_dev *fd_dev = se_dev->se_dev_su_ptr;
609         ssize_t bl = 0;
610
611         bl = sprintf(b + bl, "TCM FILEIO ID: %u", fd_dev->fd_dev_id);
612         bl += sprintf(b + bl, "        File: %s  Size: %llu  Mode: %s\n",
613                 fd_dev->fd_dev_name, fd_dev->fd_dev_size,
614                 (fd_dev->fbd_flags & FDBD_USE_BUFFERED_IO) ?
615                 "Buffered" : "Synchronous");
616         return bl;
617 }
618
619 /*      fd_get_cdb(): (Part of se_subsystem_api_t template)
620  *
621  *
622  */
623 static unsigned char *fd_get_cdb(struct se_task *task)
624 {
625         struct fd_request *req = FILE_REQ(task);
626
627         return req->fd_scsi_cdb;
628 }
629
630 /*      fd_get_device_rev(): (Part of se_subsystem_api_t template)
631  *
632  *
633  */
634 static u32 fd_get_device_rev(struct se_device *dev)
635 {
636         return SCSI_SPC_2; /* Returns SPC-3 in Initiator Data */
637 }
638
639 /*      fd_get_device_type(): (Part of se_subsystem_api_t template)
640  *
641  *
642  */
643 static u32 fd_get_device_type(struct se_device *dev)
644 {
645         return TYPE_DISK;
646 }
647
648 static sector_t fd_get_blocks(struct se_device *dev)
649 {
650         struct fd_dev *fd_dev = dev->dev_ptr;
651         unsigned long long blocks_long = div_u64(fd_dev->fd_dev_size,
652                         DEV_ATTRIB(dev)->block_size);
653
654         return blocks_long;
655 }
656
657 static struct se_subsystem_api fileio_template = {
658         .name                   = "fileio",
659         .owner                  = THIS_MODULE,
660         .transport_type         = TRANSPORT_PLUGIN_VHBA_PDEV,
661         .attach_hba             = fd_attach_hba,
662         .detach_hba             = fd_detach_hba,
663         .allocate_virtdevice    = fd_allocate_virtdevice,
664         .create_virtdevice      = fd_create_virtdevice,
665         .free_device            = fd_free_device,
666         .dpo_emulated           = fd_emulated_dpo,
667         .fua_write_emulated     = fd_emulated_fua_write,
668         .fua_read_emulated      = fd_emulated_fua_read,
669         .write_cache_emulated   = fd_emulated_write_cache,
670         .alloc_task             = fd_alloc_task,
671         .do_task                = fd_do_task,
672         .do_sync_cache          = fd_emulate_sync_cache,
673         .free_task              = fd_free_task,
674         .check_configfs_dev_params = fd_check_configfs_dev_params,
675         .set_configfs_dev_params = fd_set_configfs_dev_params,
676         .show_configfs_dev_params = fd_show_configfs_dev_params,
677         .get_cdb                = fd_get_cdb,
678         .get_device_rev         = fd_get_device_rev,
679         .get_device_type        = fd_get_device_type,
680         .get_blocks             = fd_get_blocks,
681 };
682
683 static int __init fileio_module_init(void)
684 {
685         return transport_subsystem_register(&fileio_template);
686 }
687
688 static void fileio_module_exit(void)
689 {
690         transport_subsystem_release(&fileio_template);
691 }
692
693 MODULE_DESCRIPTION("TCM FILEIO subsystem plugin");
694 MODULE_AUTHOR("nab@Linux-iSCSI.org");
695 MODULE_LICENSE("GPL");
696
697 module_init(fileio_module_init);
698 module_exit(fileio_module_exit);