sg.c 71 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626
  1. /*
  2. * History:
  3. * Started: Aug 9 by Lawrence Foard (entropy@world.std.com),
  4. * to allow user process control of SCSI devices.
  5. * Development Sponsored by Killy Corp. NY NY
  6. *
  7. * Original driver (sg.c):
  8. * Copyright (C) 1992 Lawrence Foard
  9. * Version 2 and 3 extensions to driver:
  10. * Copyright (C) 1998 - 2014 Douglas Gilbert
  11. *
  12. * This program is free software; you can redistribute it and/or modify
  13. * it under the terms of the GNU General Public License as published by
  14. * the Free Software Foundation; either version 2, or (at your option)
  15. * any later version.
  16. *
  17. */
  18. static int sg_version_num = 30536; /* 2 digits for each component */
  19. #define SG_VERSION_STR "3.5.36"
  20. /*
  21. * D. P. Gilbert (dgilbert@interlog.com), notes:
  22. * - scsi logging is available via SCSI_LOG_TIMEOUT macros. First
  23. * the kernel/module needs to be built with CONFIG_SCSI_LOGGING
  24. * (otherwise the macros compile to empty statements).
  25. *
  26. */
  27. #include <linux/module.h>
  28. #include <linux/fs.h>
  29. #include <linux/kernel.h>
  30. #include <linux/sched.h>
  31. #include <linux/string.h>
  32. #include <linux/mm.h>
  33. #include <linux/errno.h>
  34. #include <linux/mtio.h>
  35. #include <linux/ioctl.h>
  36. #include <linux/slab.h>
  37. #include <linux/fcntl.h>
  38. #include <linux/init.h>
  39. #include <linux/poll.h>
  40. #include <linux/moduleparam.h>
  41. #include <linux/cdev.h>
  42. #include <linux/idr.h>
  43. #include <linux/seq_file.h>
  44. #include <linux/blkdev.h>
  45. #include <linux/delay.h>
  46. #include <linux/blktrace_api.h>
  47. #include <linux/mutex.h>
  48. #include <linux/atomic.h>
  49. #include <linux/ratelimit.h>
  50. #include <linux/uio.h>
  51. #include <linux/cred.h> /* for sg_check_file_access() */
  52. #include "scsi.h"
  53. #include <scsi/scsi_dbg.h>
  54. #include <scsi/scsi_host.h>
  55. #include <scsi/scsi_driver.h>
  56. #include <scsi/scsi_ioctl.h>
  57. #include <scsi/sg.h>
  58. #include "scsi_logging.h"
  59. #ifdef CONFIG_SCSI_PROC_FS
  60. #include <linux/proc_fs.h>
  61. static char *sg_version_date = "20140603";
  62. static int sg_proc_init(void);
  63. #endif
  64. #define SG_ALLOW_DIO_DEF 0
  65. #define SG_MAX_DEVS 32768
  66. /* SG_MAX_CDB_SIZE should be 260 (spc4r37 section 3.1.30) however the type
  67. * of sg_io_hdr::cmd_len can only represent 255. All SCSI commands greater
  68. * than 16 bytes are "variable length" whose length is a multiple of 4
  69. */
  70. #define SG_MAX_CDB_SIZE 252
  71. #define SG_DEFAULT_TIMEOUT mult_frac(SG_DEFAULT_TIMEOUT_USER, HZ, USER_HZ)
  72. int sg_big_buff = SG_DEF_RESERVED_SIZE;
  73. /* N.B. This variable is readable and writeable via
  74. /proc/scsi/sg/def_reserved_size . Each time sg_open() is called a buffer
  75. of this size (or less if there is not enough memory) will be reserved
  76. for use by this file descriptor. [Deprecated usage: this variable is also
  77. readable via /proc/sys/kernel/sg-big-buff if the sg driver is built into
  78. the kernel (i.e. it is not a module).] */
  79. static int def_reserved_size = -1; /* picks up init parameter */
  80. static int sg_allow_dio = SG_ALLOW_DIO_DEF;
  81. static int scatter_elem_sz = SG_SCATTER_SZ;
  82. static int scatter_elem_sz_prev = SG_SCATTER_SZ;
  83. #define SG_SECTOR_SZ 512
  84. static int sg_add_device(struct device *, struct class_interface *);
  85. static void sg_remove_device(struct device *, struct class_interface *);
  86. static DEFINE_IDR(sg_index_idr);
  87. static DEFINE_RWLOCK(sg_index_lock); /* Also used to lock
  88. file descriptor list for device */
  89. static struct class_interface sg_interface = {
  90. .add_dev = sg_add_device,
  91. .remove_dev = sg_remove_device,
  92. };
  93. typedef struct sg_scatter_hold { /* holding area for scsi scatter gather info */
  94. unsigned short k_use_sg; /* Count of kernel scatter-gather pieces */
  95. unsigned sglist_len; /* size of malloc'd scatter-gather list ++ */
  96. unsigned bufflen; /* Size of (aggregate) data buffer */
  97. struct page **pages;
  98. int page_order;
  99. char dio_in_use; /* 0->indirect IO (or mmap), 1->dio */
  100. unsigned char cmd_opcode; /* first byte of command */
  101. } Sg_scatter_hold;
  102. struct sg_device; /* forward declarations */
  103. struct sg_fd;
  104. typedef struct sg_request { /* SG_MAX_QUEUE requests outstanding per file */
  105. struct list_head entry; /* list entry */
  106. struct sg_fd *parentfp; /* NULL -> not in use */
  107. Sg_scatter_hold data; /* hold buffer, perhaps scatter list */
  108. sg_io_hdr_t header; /* scsi command+info, see <scsi/sg.h> */
  109. unsigned char sense_b[SCSI_SENSE_BUFFERSIZE];
  110. char res_used; /* 1 -> using reserve buffer, 0 -> not ... */
  111. char orphan; /* 1 -> drop on sight, 0 -> normal */
  112. char sg_io_owned; /* 1 -> packet belongs to SG_IO */
  113. /* done protected by rq_list_lock */
  114. char done; /* 0->before bh, 1->before read, 2->read */
  115. struct request *rq;
  116. struct bio *bio;
  117. struct execute_work ew;
  118. } Sg_request;
  119. typedef struct sg_fd { /* holds the state of a file descriptor */
  120. struct list_head sfd_siblings; /* protected by device's sfd_lock */
  121. struct sg_device *parentdp; /* owning device */
  122. wait_queue_head_t read_wait; /* queue read until command done */
  123. rwlock_t rq_list_lock; /* protect access to list in req_arr */
  124. struct mutex f_mutex; /* protect against changes in this fd */
  125. int timeout; /* defaults to SG_DEFAULT_TIMEOUT */
  126. int timeout_user; /* defaults to SG_DEFAULT_TIMEOUT_USER */
  127. Sg_scatter_hold reserve; /* buffer held for this file descriptor */
  128. struct list_head rq_list; /* head of request list */
  129. struct fasync_struct *async_qp; /* used by asynchronous notification */
  130. Sg_request req_arr[SG_MAX_QUEUE]; /* used as singly-linked list */
  131. char force_packid; /* 1 -> pack_id input to read(), 0 -> ignored */
  132. char cmd_q; /* 1 -> allow command queuing, 0 -> don't */
  133. unsigned char next_cmd_len; /* 0: automatic, >0: use on next write() */
  134. char keep_orphan; /* 0 -> drop orphan (def), 1 -> keep for read() */
  135. char mmap_called; /* 0 -> mmap() never called on this fd */
  136. char res_in_use; /* 1 -> 'reserve' array in use */
  137. struct kref f_ref;
  138. struct execute_work ew;
  139. } Sg_fd;
  140. typedef struct sg_device { /* holds the state of each scsi generic device */
  141. struct scsi_device *device;
  142. wait_queue_head_t open_wait; /* queue open() when O_EXCL present */
  143. struct mutex open_rel_lock; /* held when in open() or release() */
  144. int sg_tablesize; /* adapter's max scatter-gather table size */
  145. u32 index; /* device index number */
  146. struct list_head sfds;
  147. rwlock_t sfd_lock; /* protect access to sfd list */
  148. atomic_t detaching; /* 0->device usable, 1->device detaching */
  149. bool exclude; /* 1->open(O_EXCL) succeeded and is active */
  150. int open_cnt; /* count of opens (perhaps < num(sfds) ) */
  151. char sgdebug; /* 0->off, 1->sense, 9->dump dev, 10-> all devs */
  152. struct gendisk *disk;
  153. struct cdev * cdev; /* char_dev [sysfs: /sys/cdev/major/sg<n>] */
  154. struct kref d_ref;
  155. } Sg_device;
  156. /* tasklet or soft irq callback */
  157. static void sg_rq_end_io(struct request *rq, blk_status_t status);
  158. static int sg_start_req(Sg_request *srp, unsigned char *cmd);
  159. static int sg_finish_rem_req(Sg_request * srp);
  160. static int sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size);
  161. static ssize_t sg_new_read(Sg_fd * sfp, char __user *buf, size_t count,
  162. Sg_request * srp);
  163. static ssize_t sg_new_write(Sg_fd *sfp, struct file *file,
  164. const char __user *buf, size_t count, int blocking,
  165. int read_only, int sg_io_owned, Sg_request **o_srp);
  166. static int sg_common_write(Sg_fd * sfp, Sg_request * srp,
  167. unsigned char *cmnd, int timeout, int blocking);
  168. static int sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer);
  169. static void sg_remove_scat(Sg_fd * sfp, Sg_scatter_hold * schp);
  170. static void sg_build_reserve(Sg_fd * sfp, int req_size);
  171. static void sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size);
  172. static void sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp);
  173. static Sg_fd *sg_add_sfp(Sg_device * sdp);
  174. static void sg_remove_sfp(struct kref *);
  175. static Sg_request *sg_get_rq_mark(Sg_fd * sfp, int pack_id);
  176. static Sg_request *sg_add_request(Sg_fd * sfp);
  177. static int sg_remove_request(Sg_fd * sfp, Sg_request * srp);
  178. static Sg_device *sg_get_dev(int dev);
  179. static void sg_device_destroy(struct kref *kref);
  180. #define SZ_SG_HEADER sizeof(struct sg_header)
  181. #define SZ_SG_IO_HDR sizeof(sg_io_hdr_t)
  182. #define SZ_SG_IOVEC sizeof(sg_iovec_t)
  183. #define SZ_SG_REQ_INFO sizeof(sg_req_info_t)
  184. #define sg_printk(prefix, sdp, fmt, a...) \
  185. sdev_prefix_printk(prefix, (sdp)->device, \
  186. (sdp)->disk->disk_name, fmt, ##a)
  187. /*
  188. * The SCSI interfaces that use read() and write() as an asynchronous variant of
  189. * ioctl(..., SG_IO, ...) are fundamentally unsafe, since there are lots of ways
  190. * to trigger read() and write() calls from various contexts with elevated
  191. * privileges. This can lead to kernel memory corruption (e.g. if these
  192. * interfaces are called through splice()) and privilege escalation inside
  193. * userspace (e.g. if a process with access to such a device passes a file
  194. * descriptor to a SUID binary as stdin/stdout/stderr).
  195. *
  196. * This function provides protection for the legacy API by restricting the
  197. * calling context.
  198. */
  199. static int sg_check_file_access(struct file *filp, const char *caller)
  200. {
  201. if (filp->f_cred != current_real_cred()) {
  202. pr_err_once("%s: process %d (%s) changed security contexts after opening file descriptor, this is not allowed.\n",
  203. caller, task_tgid_vnr(current), current->comm);
  204. return -EPERM;
  205. }
  206. if (uaccess_kernel()) {
  207. pr_err_once("%s: process %d (%s) called from kernel context, this is not allowed.\n",
  208. caller, task_tgid_vnr(current), current->comm);
  209. return -EACCES;
  210. }
  211. return 0;
  212. }
  213. static int sg_allow_access(struct file *filp, unsigned char *cmd)
  214. {
  215. struct sg_fd *sfp = filp->private_data;
  216. if (sfp->parentdp->device->type == TYPE_SCANNER)
  217. return 0;
  218. return blk_verify_command(cmd, filp->f_mode);
  219. }
  220. static int
  221. open_wait(Sg_device *sdp, int flags)
  222. {
  223. int retval = 0;
  224. if (flags & O_EXCL) {
  225. while (sdp->open_cnt > 0) {
  226. mutex_unlock(&sdp->open_rel_lock);
  227. retval = wait_event_interruptible(sdp->open_wait,
  228. (atomic_read(&sdp->detaching) ||
  229. !sdp->open_cnt));
  230. mutex_lock(&sdp->open_rel_lock);
  231. if (retval) /* -ERESTARTSYS */
  232. return retval;
  233. if (atomic_read(&sdp->detaching))
  234. return -ENODEV;
  235. }
  236. } else {
  237. while (sdp->exclude) {
  238. mutex_unlock(&sdp->open_rel_lock);
  239. retval = wait_event_interruptible(sdp->open_wait,
  240. (atomic_read(&sdp->detaching) ||
  241. !sdp->exclude));
  242. mutex_lock(&sdp->open_rel_lock);
  243. if (retval) /* -ERESTARTSYS */
  244. return retval;
  245. if (atomic_read(&sdp->detaching))
  246. return -ENODEV;
  247. }
  248. }
  249. return retval;
  250. }
  251. /* Returns 0 on success, else a negated errno value */
  252. static int
  253. sg_open(struct inode *inode, struct file *filp)
  254. {
  255. int dev = iminor(inode);
  256. int flags = filp->f_flags;
  257. struct request_queue *q;
  258. Sg_device *sdp;
  259. Sg_fd *sfp;
  260. int retval;
  261. nonseekable_open(inode, filp);
  262. if ((flags & O_EXCL) && (O_RDONLY == (flags & O_ACCMODE)))
  263. return -EPERM; /* Can't lock it with read only access */
  264. sdp = sg_get_dev(dev);
  265. if (IS_ERR(sdp))
  266. return PTR_ERR(sdp);
  267. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
  268. "sg_open: flags=0x%x\n", flags));
  269. /* This driver's module count bumped by fops_get in <linux/fs.h> */
  270. /* Prevent the device driver from vanishing while we sleep */
  271. retval = scsi_device_get(sdp->device);
  272. if (retval)
  273. goto sg_put;
  274. retval = scsi_autopm_get_device(sdp->device);
  275. if (retval)
  276. goto sdp_put;
  277. /* scsi_block_when_processing_errors() may block so bypass
  278. * check if O_NONBLOCK. Permits SCSI commands to be issued
  279. * during error recovery. Tread carefully. */
  280. if (!((flags & O_NONBLOCK) ||
  281. scsi_block_when_processing_errors(sdp->device))) {
  282. retval = -ENXIO;
  283. /* we are in error recovery for this device */
  284. goto error_out;
  285. }
  286. mutex_lock(&sdp->open_rel_lock);
  287. if (flags & O_NONBLOCK) {
  288. if (flags & O_EXCL) {
  289. if (sdp->open_cnt > 0) {
  290. retval = -EBUSY;
  291. goto error_mutex_locked;
  292. }
  293. } else {
  294. if (sdp->exclude) {
  295. retval = -EBUSY;
  296. goto error_mutex_locked;
  297. }
  298. }
  299. } else {
  300. retval = open_wait(sdp, flags);
  301. if (retval) /* -ERESTARTSYS or -ENODEV */
  302. goto error_mutex_locked;
  303. }
  304. /* N.B. at this point we are holding the open_rel_lock */
  305. if (flags & O_EXCL)
  306. sdp->exclude = true;
  307. if (sdp->open_cnt < 1) { /* no existing opens */
  308. sdp->sgdebug = 0;
  309. q = sdp->device->request_queue;
  310. sdp->sg_tablesize = queue_max_segments(q);
  311. }
  312. sfp = sg_add_sfp(sdp);
  313. if (IS_ERR(sfp)) {
  314. retval = PTR_ERR(sfp);
  315. goto out_undo;
  316. }
  317. filp->private_data = sfp;
  318. sdp->open_cnt++;
  319. mutex_unlock(&sdp->open_rel_lock);
  320. retval = 0;
  321. sg_put:
  322. kref_put(&sdp->d_ref, sg_device_destroy);
  323. return retval;
  324. out_undo:
  325. if (flags & O_EXCL) {
  326. sdp->exclude = false; /* undo if error */
  327. wake_up_interruptible(&sdp->open_wait);
  328. }
  329. error_mutex_locked:
  330. mutex_unlock(&sdp->open_rel_lock);
  331. error_out:
  332. scsi_autopm_put_device(sdp->device);
  333. sdp_put:
  334. scsi_device_put(sdp->device);
  335. goto sg_put;
  336. }
  337. /* Release resources associated with a successful sg_open()
  338. * Returns 0 on success, else a negated errno value */
  339. static int
  340. sg_release(struct inode *inode, struct file *filp)
  341. {
  342. Sg_device *sdp;
  343. Sg_fd *sfp;
  344. if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
  345. return -ENXIO;
  346. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp, "sg_release\n"));
  347. mutex_lock(&sdp->open_rel_lock);
  348. scsi_autopm_put_device(sdp->device);
  349. kref_put(&sfp->f_ref, sg_remove_sfp);
  350. sdp->open_cnt--;
  351. /* possibly many open()s waiting on exlude clearing, start many;
  352. * only open(O_EXCL)s wait on 0==open_cnt so only start one */
  353. if (sdp->exclude) {
  354. sdp->exclude = false;
  355. wake_up_interruptible_all(&sdp->open_wait);
  356. } else if (0 == sdp->open_cnt) {
  357. wake_up_interruptible(&sdp->open_wait);
  358. }
  359. mutex_unlock(&sdp->open_rel_lock);
  360. return 0;
  361. }
  362. static ssize_t
  363. sg_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
  364. {
  365. Sg_device *sdp;
  366. Sg_fd *sfp;
  367. Sg_request *srp;
  368. int req_pack_id = -1;
  369. sg_io_hdr_t *hp;
  370. struct sg_header *old_hdr = NULL;
  371. int retval = 0;
  372. /*
  373. * This could cause a response to be stranded. Close the associated
  374. * file descriptor to free up any resources being held.
  375. */
  376. retval = sg_check_file_access(filp, __func__);
  377. if (retval)
  378. return retval;
  379. if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
  380. return -ENXIO;
  381. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
  382. "sg_read: count=%d\n", (int) count));
  383. if (!access_ok(VERIFY_WRITE, buf, count))
  384. return -EFAULT;
  385. if (sfp->force_packid && (count >= SZ_SG_HEADER)) {
  386. old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
  387. if (!old_hdr)
  388. return -ENOMEM;
  389. if (__copy_from_user(old_hdr, buf, SZ_SG_HEADER)) {
  390. retval = -EFAULT;
  391. goto free_old_hdr;
  392. }
  393. if (old_hdr->reply_len < 0) {
  394. if (count >= SZ_SG_IO_HDR) {
  395. sg_io_hdr_t *new_hdr;
  396. new_hdr = kmalloc(SZ_SG_IO_HDR, GFP_KERNEL);
  397. if (!new_hdr) {
  398. retval = -ENOMEM;
  399. goto free_old_hdr;
  400. }
  401. retval =__copy_from_user
  402. (new_hdr, buf, SZ_SG_IO_HDR);
  403. req_pack_id = new_hdr->pack_id;
  404. kfree(new_hdr);
  405. if (retval) {
  406. retval = -EFAULT;
  407. goto free_old_hdr;
  408. }
  409. }
  410. } else
  411. req_pack_id = old_hdr->pack_id;
  412. }
  413. srp = sg_get_rq_mark(sfp, req_pack_id);
  414. if (!srp) { /* now wait on packet to arrive */
  415. if (atomic_read(&sdp->detaching)) {
  416. retval = -ENODEV;
  417. goto free_old_hdr;
  418. }
  419. if (filp->f_flags & O_NONBLOCK) {
  420. retval = -EAGAIN;
  421. goto free_old_hdr;
  422. }
  423. retval = wait_event_interruptible(sfp->read_wait,
  424. (atomic_read(&sdp->detaching) ||
  425. (srp = sg_get_rq_mark(sfp, req_pack_id))));
  426. if (atomic_read(&sdp->detaching)) {
  427. retval = -ENODEV;
  428. goto free_old_hdr;
  429. }
  430. if (retval) {
  431. /* -ERESTARTSYS as signal hit process */
  432. goto free_old_hdr;
  433. }
  434. }
  435. if (srp->header.interface_id != '\0') {
  436. retval = sg_new_read(sfp, buf, count, srp);
  437. goto free_old_hdr;
  438. }
  439. hp = &srp->header;
  440. if (old_hdr == NULL) {
  441. old_hdr = kmalloc(SZ_SG_HEADER, GFP_KERNEL);
  442. if (! old_hdr) {
  443. retval = -ENOMEM;
  444. goto free_old_hdr;
  445. }
  446. }
  447. memset(old_hdr, 0, SZ_SG_HEADER);
  448. old_hdr->reply_len = (int) hp->timeout;
  449. old_hdr->pack_len = old_hdr->reply_len; /* old, strange behaviour */
  450. old_hdr->pack_id = hp->pack_id;
  451. old_hdr->twelve_byte =
  452. ((srp->data.cmd_opcode >= 0xc0) && (12 == hp->cmd_len)) ? 1 : 0;
  453. old_hdr->target_status = hp->masked_status;
  454. old_hdr->host_status = hp->host_status;
  455. old_hdr->driver_status = hp->driver_status;
  456. if ((CHECK_CONDITION & hp->masked_status) ||
  457. (DRIVER_SENSE & hp->driver_status))
  458. memcpy(old_hdr->sense_buffer, srp->sense_b,
  459. sizeof (old_hdr->sense_buffer));
  460. switch (hp->host_status) {
  461. /* This setup of 'result' is for backward compatibility and is best
  462. ignored by the user who should use target, host + driver status */
  463. case DID_OK:
  464. case DID_PASSTHROUGH:
  465. case DID_SOFT_ERROR:
  466. old_hdr->result = 0;
  467. break;
  468. case DID_NO_CONNECT:
  469. case DID_BUS_BUSY:
  470. case DID_TIME_OUT:
  471. old_hdr->result = EBUSY;
  472. break;
  473. case DID_BAD_TARGET:
  474. case DID_ABORT:
  475. case DID_PARITY:
  476. case DID_RESET:
  477. case DID_BAD_INTR:
  478. old_hdr->result = EIO;
  479. break;
  480. case DID_ERROR:
  481. old_hdr->result = (srp->sense_b[0] == 0 &&
  482. hp->masked_status == GOOD) ? 0 : EIO;
  483. break;
  484. default:
  485. old_hdr->result = EIO;
  486. break;
  487. }
  488. /* Now copy the result back to the user buffer. */
  489. if (count >= SZ_SG_HEADER) {
  490. if (__copy_to_user(buf, old_hdr, SZ_SG_HEADER)) {
  491. retval = -EFAULT;
  492. goto free_old_hdr;
  493. }
  494. buf += SZ_SG_HEADER;
  495. if (count > old_hdr->reply_len)
  496. count = old_hdr->reply_len;
  497. if (count > SZ_SG_HEADER) {
  498. if (sg_read_oxfer(srp, buf, count - SZ_SG_HEADER)) {
  499. retval = -EFAULT;
  500. goto free_old_hdr;
  501. }
  502. }
  503. } else
  504. count = (old_hdr->result == 0) ? 0 : -EIO;
  505. sg_finish_rem_req(srp);
  506. sg_remove_request(sfp, srp);
  507. retval = count;
  508. free_old_hdr:
  509. kfree(old_hdr);
  510. return retval;
  511. }
  512. static ssize_t
  513. sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
  514. {
  515. sg_io_hdr_t *hp = &srp->header;
  516. int err = 0, err2;
  517. int len;
  518. if (count < SZ_SG_IO_HDR) {
  519. err = -EINVAL;
  520. goto err_out;
  521. }
  522. hp->sb_len_wr = 0;
  523. if ((hp->mx_sb_len > 0) && hp->sbp) {
  524. if ((CHECK_CONDITION & hp->masked_status) ||
  525. (DRIVER_SENSE & hp->driver_status)) {
  526. int sb_len = SCSI_SENSE_BUFFERSIZE;
  527. sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len;
  528. len = 8 + (int) srp->sense_b[7]; /* Additional sense length field */
  529. len = (len > sb_len) ? sb_len : len;
  530. if (copy_to_user(hp->sbp, srp->sense_b, len)) {
  531. err = -EFAULT;
  532. goto err_out;
  533. }
  534. hp->sb_len_wr = len;
  535. }
  536. }
  537. if (hp->masked_status || hp->host_status || hp->driver_status)
  538. hp->info |= SG_INFO_CHECK;
  539. if (copy_to_user(buf, hp, SZ_SG_IO_HDR)) {
  540. err = -EFAULT;
  541. goto err_out;
  542. }
  543. err_out:
  544. err2 = sg_finish_rem_req(srp);
  545. sg_remove_request(sfp, srp);
  546. return err ? : err2 ? : count;
  547. }
  548. static ssize_t
  549. sg_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
  550. {
  551. int mxsize, cmd_size, k;
  552. int input_size, blocking;
  553. unsigned char opcode;
  554. Sg_device *sdp;
  555. Sg_fd *sfp;
  556. Sg_request *srp;
  557. struct sg_header old_hdr;
  558. sg_io_hdr_t *hp;
  559. unsigned char cmnd[SG_MAX_CDB_SIZE];
  560. int retval;
  561. retval = sg_check_file_access(filp, __func__);
  562. if (retval)
  563. return retval;
  564. if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
  565. return -ENXIO;
  566. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
  567. "sg_write: count=%d\n", (int) count));
  568. if (atomic_read(&sdp->detaching))
  569. return -ENODEV;
  570. if (!((filp->f_flags & O_NONBLOCK) ||
  571. scsi_block_when_processing_errors(sdp->device)))
  572. return -ENXIO;
  573. if (!access_ok(VERIFY_READ, buf, count))
  574. return -EFAULT; /* protects following copy_from_user()s + get_user()s */
  575. if (count < SZ_SG_HEADER)
  576. return -EIO;
  577. if (__copy_from_user(&old_hdr, buf, SZ_SG_HEADER))
  578. return -EFAULT;
  579. blocking = !(filp->f_flags & O_NONBLOCK);
  580. if (old_hdr.reply_len < 0)
  581. return sg_new_write(sfp, filp, buf, count,
  582. blocking, 0, 0, NULL);
  583. if (count < (SZ_SG_HEADER + 6))
  584. return -EIO; /* The minimum scsi command length is 6 bytes. */
  585. if (!(srp = sg_add_request(sfp))) {
  586. SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sdp,
  587. "sg_write: queue full\n"));
  588. return -EDOM;
  589. }
  590. buf += SZ_SG_HEADER;
  591. __get_user(opcode, buf);
  592. mutex_lock(&sfp->f_mutex);
  593. if (sfp->next_cmd_len > 0) {
  594. cmd_size = sfp->next_cmd_len;
  595. sfp->next_cmd_len = 0; /* reset so only this write() effected */
  596. } else {
  597. cmd_size = COMMAND_SIZE(opcode); /* based on SCSI command group */
  598. if ((opcode >= 0xc0) && old_hdr.twelve_byte)
  599. cmd_size = 12;
  600. }
  601. mutex_unlock(&sfp->f_mutex);
  602. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sdp,
  603. "sg_write: scsi opcode=0x%02x, cmd_size=%d\n", (int) opcode, cmd_size));
  604. /* Determine buffer size. */
  605. input_size = count - cmd_size;
  606. mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len;
  607. mxsize -= SZ_SG_HEADER;
  608. input_size -= SZ_SG_HEADER;
  609. if (input_size < 0) {
  610. sg_remove_request(sfp, srp);
  611. return -EIO; /* User did not pass enough bytes for this command. */
  612. }
  613. hp = &srp->header;
  614. hp->interface_id = '\0'; /* indicator of old interface tunnelled */
  615. hp->cmd_len = (unsigned char) cmd_size;
  616. hp->iovec_count = 0;
  617. hp->mx_sb_len = 0;
  618. if (input_size > 0)
  619. hp->dxfer_direction = (old_hdr.reply_len > SZ_SG_HEADER) ?
  620. SG_DXFER_TO_FROM_DEV : SG_DXFER_TO_DEV;
  621. else
  622. hp->dxfer_direction = (mxsize > 0) ? SG_DXFER_FROM_DEV : SG_DXFER_NONE;
  623. hp->dxfer_len = mxsize;
  624. if ((hp->dxfer_direction == SG_DXFER_TO_DEV) ||
  625. (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV))
  626. hp->dxferp = (char __user *)buf + cmd_size;
  627. else
  628. hp->dxferp = NULL;
  629. hp->sbp = NULL;
  630. hp->timeout = old_hdr.reply_len; /* structure abuse ... */
  631. hp->flags = input_size; /* structure abuse ... */
  632. hp->pack_id = old_hdr.pack_id;
  633. hp->usr_ptr = NULL;
  634. if (__copy_from_user(cmnd, buf, cmd_size)) {
  635. sg_remove_request(sfp, srp);
  636. return -EFAULT;
  637. }
  638. /*
  639. * SG_DXFER_TO_FROM_DEV is functionally equivalent to SG_DXFER_FROM_DEV,
  640. * but is is possible that the app intended SG_DXFER_TO_DEV, because there
  641. * is a non-zero input_size, so emit a warning.
  642. */
  643. if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) {
  644. printk_ratelimited(KERN_WARNING
  645. "sg_write: data in/out %d/%d bytes "
  646. "for SCSI command 0x%x-- guessing "
  647. "data in;\n program %s not setting "
  648. "count and/or reply_len properly\n",
  649. old_hdr.reply_len - (int)SZ_SG_HEADER,
  650. input_size, (unsigned int) cmnd[0],
  651. current->comm);
  652. }
  653. k = sg_common_write(sfp, srp, cmnd, sfp->timeout, blocking);
  654. return (k < 0) ? k : count;
  655. }
  656. static ssize_t
  657. sg_new_write(Sg_fd *sfp, struct file *file, const char __user *buf,
  658. size_t count, int blocking, int read_only, int sg_io_owned,
  659. Sg_request **o_srp)
  660. {
  661. int k;
  662. Sg_request *srp;
  663. sg_io_hdr_t *hp;
  664. unsigned char cmnd[SG_MAX_CDB_SIZE];
  665. int timeout;
  666. unsigned long ul_timeout;
  667. if (count < SZ_SG_IO_HDR)
  668. return -EINVAL;
  669. if (!access_ok(VERIFY_READ, buf, count))
  670. return -EFAULT; /* protects following copy_from_user()s + get_user()s */
  671. sfp->cmd_q = 1; /* when sg_io_hdr seen, set command queuing on */
  672. if (!(srp = sg_add_request(sfp))) {
  673. SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sfp->parentdp,
  674. "sg_new_write: queue full\n"));
  675. return -EDOM;
  676. }
  677. srp->sg_io_owned = sg_io_owned;
  678. hp = &srp->header;
  679. if (__copy_from_user(hp, buf, SZ_SG_IO_HDR)) {
  680. sg_remove_request(sfp, srp);
  681. return -EFAULT;
  682. }
  683. if (hp->interface_id != 'S') {
  684. sg_remove_request(sfp, srp);
  685. return -ENOSYS;
  686. }
  687. if (hp->flags & SG_FLAG_MMAP_IO) {
  688. if (hp->dxfer_len > sfp->reserve.bufflen) {
  689. sg_remove_request(sfp, srp);
  690. return -ENOMEM; /* MMAP_IO size must fit in reserve buffer */
  691. }
  692. if (hp->flags & SG_FLAG_DIRECT_IO) {
  693. sg_remove_request(sfp, srp);
  694. return -EINVAL; /* either MMAP_IO or DIRECT_IO (not both) */
  695. }
  696. if (sfp->res_in_use) {
  697. sg_remove_request(sfp, srp);
  698. return -EBUSY; /* reserve buffer already being used */
  699. }
  700. }
  701. ul_timeout = msecs_to_jiffies(srp->header.timeout);
  702. timeout = (ul_timeout < INT_MAX) ? ul_timeout : INT_MAX;
  703. if ((!hp->cmdp) || (hp->cmd_len < 6) || (hp->cmd_len > sizeof (cmnd))) {
  704. sg_remove_request(sfp, srp);
  705. return -EMSGSIZE;
  706. }
  707. if (!access_ok(VERIFY_READ, hp->cmdp, hp->cmd_len)) {
  708. sg_remove_request(sfp, srp);
  709. return -EFAULT; /* protects following copy_from_user()s + get_user()s */
  710. }
  711. if (__copy_from_user(cmnd, hp->cmdp, hp->cmd_len)) {
  712. sg_remove_request(sfp, srp);
  713. return -EFAULT;
  714. }
  715. if (read_only && sg_allow_access(file, cmnd)) {
  716. sg_remove_request(sfp, srp);
  717. return -EPERM;
  718. }
  719. k = sg_common_write(sfp, srp, cmnd, timeout, blocking);
  720. if (k < 0)
  721. return k;
  722. if (o_srp)
  723. *o_srp = srp;
  724. return count;
  725. }
  726. static int
  727. sg_common_write(Sg_fd * sfp, Sg_request * srp,
  728. unsigned char *cmnd, int timeout, int blocking)
  729. {
  730. int k, at_head;
  731. Sg_device *sdp = sfp->parentdp;
  732. sg_io_hdr_t *hp = &srp->header;
  733. srp->data.cmd_opcode = cmnd[0]; /* hold opcode of command */
  734. hp->status = 0;
  735. hp->masked_status = 0;
  736. hp->msg_status = 0;
  737. hp->info = 0;
  738. hp->host_status = 0;
  739. hp->driver_status = 0;
  740. hp->resid = 0;
  741. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
  742. "sg_common_write: scsi opcode=0x%02x, cmd_size=%d\n",
  743. (int) cmnd[0], (int) hp->cmd_len));
  744. if (hp->dxfer_len >= SZ_256M) {
  745. sg_remove_request(sfp, srp);
  746. return -EINVAL;
  747. }
  748. k = sg_start_req(srp, cmnd);
  749. if (k) {
  750. SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sfp->parentdp,
  751. "sg_common_write: start_req err=%d\n", k));
  752. sg_finish_rem_req(srp);
  753. sg_remove_request(sfp, srp);
  754. return k; /* probably out of space --> ENOMEM */
  755. }
  756. if (atomic_read(&sdp->detaching)) {
  757. if (srp->bio) {
  758. scsi_req_free_cmd(scsi_req(srp->rq));
  759. blk_end_request_all(srp->rq, BLK_STS_IOERR);
  760. srp->rq = NULL;
  761. }
  762. sg_finish_rem_req(srp);
  763. sg_remove_request(sfp, srp);
  764. return -ENODEV;
  765. }
  766. hp->duration = jiffies_to_msecs(jiffies);
  767. if (hp->interface_id != '\0' && /* v3 (or later) interface */
  768. (SG_FLAG_Q_AT_TAIL & hp->flags))
  769. at_head = 0;
  770. else
  771. at_head = 1;
  772. srp->rq->timeout = timeout;
  773. kref_get(&sfp->f_ref); /* sg_rq_end_io() does kref_put(). */
  774. blk_execute_rq_nowait(sdp->device->request_queue, sdp->disk,
  775. srp->rq, at_head, sg_rq_end_io);
  776. return 0;
  777. }
  778. static int srp_done(Sg_fd *sfp, Sg_request *srp)
  779. {
  780. unsigned long flags;
  781. int ret;
  782. read_lock_irqsave(&sfp->rq_list_lock, flags);
  783. ret = srp->done;
  784. read_unlock_irqrestore(&sfp->rq_list_lock, flags);
  785. return ret;
  786. }
  787. static int max_sectors_bytes(struct request_queue *q)
  788. {
  789. unsigned int max_sectors = queue_max_sectors(q);
  790. max_sectors = min_t(unsigned int, max_sectors, INT_MAX >> 9);
  791. return max_sectors << 9;
  792. }
  793. static void
  794. sg_fill_request_table(Sg_fd *sfp, sg_req_info_t *rinfo)
  795. {
  796. Sg_request *srp;
  797. int val;
  798. unsigned int ms;
  799. val = 0;
  800. list_for_each_entry(srp, &sfp->rq_list, entry) {
  801. if (val >= SG_MAX_QUEUE)
  802. break;
  803. rinfo[val].req_state = srp->done + 1;
  804. rinfo[val].problem =
  805. srp->header.masked_status &
  806. srp->header.host_status &
  807. srp->header.driver_status;
  808. if (srp->done)
  809. rinfo[val].duration =
  810. srp->header.duration;
  811. else {
  812. ms = jiffies_to_msecs(jiffies);
  813. rinfo[val].duration =
  814. (ms > srp->header.duration) ?
  815. (ms - srp->header.duration) : 0;
  816. }
  817. rinfo[val].orphan = srp->orphan;
  818. rinfo[val].sg_io_owned = srp->sg_io_owned;
  819. rinfo[val].pack_id = srp->header.pack_id;
  820. rinfo[val].usr_ptr = srp->header.usr_ptr;
  821. val++;
  822. }
  823. }
  824. static long
  825. sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
  826. {
  827. void __user *p = (void __user *)arg;
  828. int __user *ip = p;
  829. int result, val, read_only;
  830. Sg_device *sdp;
  831. Sg_fd *sfp;
  832. Sg_request *srp;
  833. unsigned long iflags;
  834. if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
  835. return -ENXIO;
  836. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
  837. "sg_ioctl: cmd=0x%x\n", (int) cmd_in));
  838. read_only = (O_RDWR != (filp->f_flags & O_ACCMODE));
  839. switch (cmd_in) {
  840. case SG_IO:
  841. if (atomic_read(&sdp->detaching))
  842. return -ENODEV;
  843. if (!scsi_block_when_processing_errors(sdp->device))
  844. return -ENXIO;
  845. if (!access_ok(VERIFY_WRITE, p, SZ_SG_IO_HDR))
  846. return -EFAULT;
  847. result = sg_new_write(sfp, filp, p, SZ_SG_IO_HDR,
  848. 1, read_only, 1, &srp);
  849. if (result < 0)
  850. return result;
  851. result = wait_event_interruptible(sfp->read_wait,
  852. (srp_done(sfp, srp) || atomic_read(&sdp->detaching)));
  853. if (atomic_read(&sdp->detaching))
  854. return -ENODEV;
  855. write_lock_irq(&sfp->rq_list_lock);
  856. if (srp->done) {
  857. srp->done = 2;
  858. write_unlock_irq(&sfp->rq_list_lock);
  859. result = sg_new_read(sfp, p, SZ_SG_IO_HDR, srp);
  860. return (result < 0) ? result : 0;
  861. }
  862. srp->orphan = 1;
  863. write_unlock_irq(&sfp->rq_list_lock);
  864. return result; /* -ERESTARTSYS because signal hit process */
  865. case SG_SET_TIMEOUT:
  866. result = get_user(val, ip);
  867. if (result)
  868. return result;
  869. if (val < 0)
  870. return -EIO;
  871. if (val >= mult_frac((s64)INT_MAX, USER_HZ, HZ))
  872. val = min_t(s64, mult_frac((s64)INT_MAX, USER_HZ, HZ),
  873. INT_MAX);
  874. sfp->timeout_user = val;
  875. sfp->timeout = mult_frac(val, HZ, USER_HZ);
  876. return 0;
  877. case SG_GET_TIMEOUT: /* N.B. User receives timeout as return value */
  878. /* strange ..., for backward compatibility */
  879. return sfp->timeout_user;
  880. case SG_SET_FORCE_LOW_DMA:
  881. /*
  882. * N.B. This ioctl never worked properly, but failed to
  883. * return an error value. So returning '0' to keep compability
  884. * with legacy applications.
  885. */
  886. return 0;
  887. case SG_GET_LOW_DMA:
  888. return put_user((int) sdp->device->host->unchecked_isa_dma, ip);
  889. case SG_GET_SCSI_ID:
  890. if (!access_ok(VERIFY_WRITE, p, sizeof (sg_scsi_id_t)))
  891. return -EFAULT;
  892. else {
  893. sg_scsi_id_t __user *sg_idp = p;
  894. if (atomic_read(&sdp->detaching))
  895. return -ENODEV;
  896. __put_user((int) sdp->device->host->host_no,
  897. &sg_idp->host_no);
  898. __put_user((int) sdp->device->channel,
  899. &sg_idp->channel);
  900. __put_user((int) sdp->device->id, &sg_idp->scsi_id);
  901. __put_user((int) sdp->device->lun, &sg_idp->lun);
  902. __put_user((int) sdp->device->type, &sg_idp->scsi_type);
  903. __put_user((short) sdp->device->host->cmd_per_lun,
  904. &sg_idp->h_cmd_per_lun);
  905. __put_user((short) sdp->device->queue_depth,
  906. &sg_idp->d_queue_depth);
  907. __put_user(0, &sg_idp->unused[0]);
  908. __put_user(0, &sg_idp->unused[1]);
  909. return 0;
  910. }
  911. case SG_SET_FORCE_PACK_ID:
  912. result = get_user(val, ip);
  913. if (result)
  914. return result;
  915. sfp->force_packid = val ? 1 : 0;
  916. return 0;
  917. case SG_GET_PACK_ID:
  918. if (!access_ok(VERIFY_WRITE, ip, sizeof (int)))
  919. return -EFAULT;
  920. read_lock_irqsave(&sfp->rq_list_lock, iflags);
  921. list_for_each_entry(srp, &sfp->rq_list, entry) {
  922. if ((1 == srp->done) && (!srp->sg_io_owned)) {
  923. read_unlock_irqrestore(&sfp->rq_list_lock,
  924. iflags);
  925. __put_user(srp->header.pack_id, ip);
  926. return 0;
  927. }
  928. }
  929. read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  930. __put_user(-1, ip);
  931. return 0;
  932. case SG_GET_NUM_WAITING:
  933. read_lock_irqsave(&sfp->rq_list_lock, iflags);
  934. val = 0;
  935. list_for_each_entry(srp, &sfp->rq_list, entry) {
  936. if ((1 == srp->done) && (!srp->sg_io_owned))
  937. ++val;
  938. }
  939. read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  940. return put_user(val, ip);
  941. case SG_GET_SG_TABLESIZE:
  942. return put_user(sdp->sg_tablesize, ip);
  943. case SG_SET_RESERVED_SIZE:
  944. result = get_user(val, ip);
  945. if (result)
  946. return result;
  947. if (val < 0)
  948. return -EINVAL;
  949. val = min_t(int, val,
  950. max_sectors_bytes(sdp->device->request_queue));
  951. mutex_lock(&sfp->f_mutex);
  952. if (val != sfp->reserve.bufflen) {
  953. if (sfp->mmap_called ||
  954. sfp->res_in_use) {
  955. mutex_unlock(&sfp->f_mutex);
  956. return -EBUSY;
  957. }
  958. sg_remove_scat(sfp, &sfp->reserve);
  959. sg_build_reserve(sfp, val);
  960. }
  961. mutex_unlock(&sfp->f_mutex);
  962. return 0;
  963. case SG_GET_RESERVED_SIZE:
  964. val = min_t(int, sfp->reserve.bufflen,
  965. max_sectors_bytes(sdp->device->request_queue));
  966. return put_user(val, ip);
  967. case SG_SET_COMMAND_Q:
  968. result = get_user(val, ip);
  969. if (result)
  970. return result;
  971. sfp->cmd_q = val ? 1 : 0;
  972. return 0;
  973. case SG_GET_COMMAND_Q:
  974. return put_user((int) sfp->cmd_q, ip);
  975. case SG_SET_KEEP_ORPHAN:
  976. result = get_user(val, ip);
  977. if (result)
  978. return result;
  979. sfp->keep_orphan = val;
  980. return 0;
  981. case SG_GET_KEEP_ORPHAN:
  982. return put_user((int) sfp->keep_orphan, ip);
  983. case SG_NEXT_CMD_LEN:
  984. result = get_user(val, ip);
  985. if (result)
  986. return result;
  987. if (val > SG_MAX_CDB_SIZE)
  988. return -ENOMEM;
  989. sfp->next_cmd_len = (val > 0) ? val : 0;
  990. return 0;
  991. case SG_GET_VERSION_NUM:
  992. return put_user(sg_version_num, ip);
  993. case SG_GET_ACCESS_COUNT:
  994. /* faked - we don't have a real access count anymore */
  995. val = (sdp->device ? 1 : 0);
  996. return put_user(val, ip);
  997. case SG_GET_REQUEST_TABLE:
  998. if (!access_ok(VERIFY_WRITE, p, SZ_SG_REQ_INFO * SG_MAX_QUEUE))
  999. return -EFAULT;
  1000. else {
  1001. sg_req_info_t *rinfo;
  1002. rinfo = kcalloc(SG_MAX_QUEUE, SZ_SG_REQ_INFO,
  1003. GFP_KERNEL);
  1004. if (!rinfo)
  1005. return -ENOMEM;
  1006. read_lock_irqsave(&sfp->rq_list_lock, iflags);
  1007. sg_fill_request_table(sfp, rinfo);
  1008. read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  1009. result = __copy_to_user(p, rinfo,
  1010. SZ_SG_REQ_INFO * SG_MAX_QUEUE);
  1011. result = result ? -EFAULT : 0;
  1012. kfree(rinfo);
  1013. return result;
  1014. }
  1015. case SG_EMULATED_HOST:
  1016. if (atomic_read(&sdp->detaching))
  1017. return -ENODEV;
  1018. return put_user(sdp->device->host->hostt->emulated, ip);
  1019. case SCSI_IOCTL_SEND_COMMAND:
  1020. if (atomic_read(&sdp->detaching))
  1021. return -ENODEV;
  1022. return sg_scsi_ioctl(sdp->device->request_queue, NULL, filp->f_mode, p);
  1023. case SG_SET_DEBUG:
  1024. result = get_user(val, ip);
  1025. if (result)
  1026. return result;
  1027. sdp->sgdebug = (char) val;
  1028. return 0;
  1029. case BLKSECTGET:
  1030. return put_user(max_sectors_bytes(sdp->device->request_queue),
  1031. ip);
  1032. case BLKTRACESETUP:
  1033. return blk_trace_setup(sdp->device->request_queue,
  1034. sdp->disk->disk_name,
  1035. MKDEV(SCSI_GENERIC_MAJOR, sdp->index),
  1036. NULL, p);
  1037. case BLKTRACESTART:
  1038. return blk_trace_startstop(sdp->device->request_queue, 1);
  1039. case BLKTRACESTOP:
  1040. return blk_trace_startstop(sdp->device->request_queue, 0);
  1041. case BLKTRACETEARDOWN:
  1042. return blk_trace_remove(sdp->device->request_queue);
  1043. case SCSI_IOCTL_GET_IDLUN:
  1044. case SCSI_IOCTL_GET_BUS_NUMBER:
  1045. case SCSI_IOCTL_PROBE_HOST:
  1046. case SG_GET_TRANSFORM:
  1047. case SG_SCSI_RESET:
  1048. if (atomic_read(&sdp->detaching))
  1049. return -ENODEV;
  1050. break;
  1051. default:
  1052. if (read_only)
  1053. return -EPERM; /* don't know so take safe approach */
  1054. break;
  1055. }
  1056. result = scsi_ioctl_block_when_processing_errors(sdp->device,
  1057. cmd_in, filp->f_flags & O_NDELAY);
  1058. if (result)
  1059. return result;
  1060. return scsi_ioctl(sdp->device, cmd_in, p);
  1061. }
  1062. #ifdef CONFIG_COMPAT
  1063. static long sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
  1064. {
  1065. Sg_device *sdp;
  1066. Sg_fd *sfp;
  1067. struct scsi_device *sdev;
  1068. if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
  1069. return -ENXIO;
  1070. sdev = sdp->device;
  1071. if (sdev->host->hostt->compat_ioctl) {
  1072. int ret;
  1073. ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg);
  1074. return ret;
  1075. }
  1076. return -ENOIOCTLCMD;
  1077. }
  1078. #endif
  1079. static __poll_t
  1080. sg_poll(struct file *filp, poll_table * wait)
  1081. {
  1082. __poll_t res = 0;
  1083. Sg_device *sdp;
  1084. Sg_fd *sfp;
  1085. Sg_request *srp;
  1086. int count = 0;
  1087. unsigned long iflags;
  1088. sfp = filp->private_data;
  1089. if (!sfp)
  1090. return EPOLLERR;
  1091. sdp = sfp->parentdp;
  1092. if (!sdp)
  1093. return EPOLLERR;
  1094. poll_wait(filp, &sfp->read_wait, wait);
  1095. read_lock_irqsave(&sfp->rq_list_lock, iflags);
  1096. list_for_each_entry(srp, &sfp->rq_list, entry) {
  1097. /* if any read waiting, flag it */
  1098. if ((0 == res) && (1 == srp->done) && (!srp->sg_io_owned))
  1099. res = EPOLLIN | EPOLLRDNORM;
  1100. ++count;
  1101. }
  1102. read_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  1103. if (atomic_read(&sdp->detaching))
  1104. res |= EPOLLHUP;
  1105. else if (!sfp->cmd_q) {
  1106. if (0 == count)
  1107. res |= EPOLLOUT | EPOLLWRNORM;
  1108. } else if (count < SG_MAX_QUEUE)
  1109. res |= EPOLLOUT | EPOLLWRNORM;
  1110. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
  1111. "sg_poll: res=0x%x\n", (__force u32) res));
  1112. return res;
  1113. }
  1114. static int
  1115. sg_fasync(int fd, struct file *filp, int mode)
  1116. {
  1117. Sg_device *sdp;
  1118. Sg_fd *sfp;
  1119. if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp)))
  1120. return -ENXIO;
  1121. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
  1122. "sg_fasync: mode=%d\n", mode));
  1123. return fasync_helper(fd, filp, mode, &sfp->async_qp);
  1124. }
  1125. static vm_fault_t
  1126. sg_vma_fault(struct vm_fault *vmf)
  1127. {
  1128. struct vm_area_struct *vma = vmf->vma;
  1129. Sg_fd *sfp;
  1130. unsigned long offset, len, sa;
  1131. Sg_scatter_hold *rsv_schp;
  1132. int k, length;
  1133. if ((NULL == vma) || (!(sfp = (Sg_fd *) vma->vm_private_data)))
  1134. return VM_FAULT_SIGBUS;
  1135. rsv_schp = &sfp->reserve;
  1136. offset = vmf->pgoff << PAGE_SHIFT;
  1137. if (offset >= rsv_schp->bufflen)
  1138. return VM_FAULT_SIGBUS;
  1139. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sfp->parentdp,
  1140. "sg_vma_fault: offset=%lu, scatg=%d\n",
  1141. offset, rsv_schp->k_use_sg));
  1142. sa = vma->vm_start;
  1143. length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
  1144. for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
  1145. len = vma->vm_end - sa;
  1146. len = (len < length) ? len : length;
  1147. if (offset < len) {
  1148. struct page *page = nth_page(rsv_schp->pages[k],
  1149. offset >> PAGE_SHIFT);
  1150. get_page(page); /* increment page count */
  1151. vmf->page = page;
  1152. return 0; /* success */
  1153. }
  1154. sa += len;
  1155. offset -= len;
  1156. }
  1157. return VM_FAULT_SIGBUS;
  1158. }
  1159. static const struct vm_operations_struct sg_mmap_vm_ops = {
  1160. .fault = sg_vma_fault,
  1161. };
  1162. static int
  1163. sg_mmap(struct file *filp, struct vm_area_struct *vma)
  1164. {
  1165. Sg_fd *sfp;
  1166. unsigned long req_sz, len, sa;
  1167. Sg_scatter_hold *rsv_schp;
  1168. int k, length;
  1169. int ret = 0;
  1170. if ((!filp) || (!vma) || (!(sfp = (Sg_fd *) filp->private_data)))
  1171. return -ENXIO;
  1172. req_sz = vma->vm_end - vma->vm_start;
  1173. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sfp->parentdp,
  1174. "sg_mmap starting, vm_start=%p, len=%d\n",
  1175. (void *) vma->vm_start, (int) req_sz));
  1176. if (vma->vm_pgoff)
  1177. return -EINVAL; /* want no offset */
  1178. rsv_schp = &sfp->reserve;
  1179. mutex_lock(&sfp->f_mutex);
  1180. if (req_sz > rsv_schp->bufflen) {
  1181. ret = -ENOMEM; /* cannot map more than reserved buffer */
  1182. goto out;
  1183. }
  1184. sa = vma->vm_start;
  1185. length = 1 << (PAGE_SHIFT + rsv_schp->page_order);
  1186. for (k = 0; k < rsv_schp->k_use_sg && sa < vma->vm_end; k++) {
  1187. len = vma->vm_end - sa;
  1188. len = (len < length) ? len : length;
  1189. sa += len;
  1190. }
  1191. sfp->mmap_called = 1;
  1192. vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP;
  1193. vma->vm_private_data = sfp;
  1194. vma->vm_ops = &sg_mmap_vm_ops;
  1195. out:
  1196. mutex_unlock(&sfp->f_mutex);
  1197. return ret;
  1198. }
  1199. static void
  1200. sg_rq_end_io_usercontext(struct work_struct *work)
  1201. {
  1202. struct sg_request *srp = container_of(work, struct sg_request, ew.work);
  1203. struct sg_fd *sfp = srp->parentfp;
  1204. sg_finish_rem_req(srp);
  1205. sg_remove_request(sfp, srp);
  1206. kref_put(&sfp->f_ref, sg_remove_sfp);
  1207. }
  1208. /*
  1209. * This function is a "bottom half" handler that is called by the mid
  1210. * level when a command is completed (or has failed).
  1211. */
  1212. static void
  1213. sg_rq_end_io(struct request *rq, blk_status_t status)
  1214. {
  1215. struct sg_request *srp = rq->end_io_data;
  1216. struct scsi_request *req = scsi_req(rq);
  1217. Sg_device *sdp;
  1218. Sg_fd *sfp;
  1219. unsigned long iflags;
  1220. unsigned int ms;
  1221. char *sense;
  1222. int result, resid, done = 1;
  1223. if (WARN_ON(srp->done != 0))
  1224. return;
  1225. sfp = srp->parentfp;
  1226. if (WARN_ON(sfp == NULL))
  1227. return;
  1228. sdp = sfp->parentdp;
  1229. if (unlikely(atomic_read(&sdp->detaching)))
  1230. pr_info("%s: device detaching\n", __func__);
  1231. sense = req->sense;
  1232. result = req->result;
  1233. resid = req->resid_len;
  1234. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sdp,
  1235. "sg_cmd_done: pack_id=%d, res=0x%x\n",
  1236. srp->header.pack_id, result));
  1237. srp->header.resid = resid;
  1238. ms = jiffies_to_msecs(jiffies);
  1239. srp->header.duration = (ms > srp->header.duration) ?
  1240. (ms - srp->header.duration) : 0;
  1241. if (0 != result) {
  1242. struct scsi_sense_hdr sshdr;
  1243. srp->header.status = 0xff & result;
  1244. srp->header.masked_status = status_byte(result);
  1245. srp->header.msg_status = msg_byte(result);
  1246. srp->header.host_status = host_byte(result);
  1247. srp->header.driver_status = driver_byte(result);
  1248. if ((sdp->sgdebug > 0) &&
  1249. ((CHECK_CONDITION == srp->header.masked_status) ||
  1250. (COMMAND_TERMINATED == srp->header.masked_status)))
  1251. __scsi_print_sense(sdp->device, __func__, sense,
  1252. SCSI_SENSE_BUFFERSIZE);
  1253. /* Following if statement is a patch supplied by Eric Youngdale */
  1254. if (driver_byte(result) != 0
  1255. && scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, &sshdr)
  1256. && !scsi_sense_is_deferred(&sshdr)
  1257. && sshdr.sense_key == UNIT_ATTENTION
  1258. && sdp->device->removable) {
  1259. /* Detected possible disc change. Set the bit - this */
  1260. /* may be used if there are filesystems using this device */
  1261. sdp->device->changed = 1;
  1262. }
  1263. }
  1264. if (req->sense_len)
  1265. memcpy(srp->sense_b, req->sense, SCSI_SENSE_BUFFERSIZE);
  1266. /* Rely on write phase to clean out srp status values, so no "else" */
  1267. /*
  1268. * Free the request as soon as it is complete so that its resources
  1269. * can be reused without waiting for userspace to read() the
  1270. * result. But keep the associated bio (if any) around until
  1271. * blk_rq_unmap_user() can be called from user context.
  1272. */
  1273. srp->rq = NULL;
  1274. scsi_req_free_cmd(scsi_req(rq));
  1275. __blk_put_request(rq->q, rq);
  1276. write_lock_irqsave(&sfp->rq_list_lock, iflags);
  1277. if (unlikely(srp->orphan)) {
  1278. if (sfp->keep_orphan)
  1279. srp->sg_io_owned = 0;
  1280. else
  1281. done = 0;
  1282. }
  1283. srp->done = done;
  1284. write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  1285. if (likely(done)) {
  1286. /* Now wake up any sg_read() that is waiting for this
  1287. * packet.
  1288. */
  1289. wake_up_interruptible(&sfp->read_wait);
  1290. kill_fasync(&sfp->async_qp, SIGPOLL, POLL_IN);
  1291. kref_put(&sfp->f_ref, sg_remove_sfp);
  1292. } else {
  1293. INIT_WORK(&srp->ew.work, sg_rq_end_io_usercontext);
  1294. schedule_work(&srp->ew.work);
  1295. }
  1296. }
  1297. static const struct file_operations sg_fops = {
  1298. .owner = THIS_MODULE,
  1299. .read = sg_read,
  1300. .write = sg_write,
  1301. .poll = sg_poll,
  1302. .unlocked_ioctl = sg_ioctl,
  1303. #ifdef CONFIG_COMPAT
  1304. .compat_ioctl = sg_compat_ioctl,
  1305. #endif
  1306. .open = sg_open,
  1307. .mmap = sg_mmap,
  1308. .release = sg_release,
  1309. .fasync = sg_fasync,
  1310. .llseek = no_llseek,
  1311. };
  1312. static struct class *sg_sysfs_class;
  1313. static int sg_sysfs_valid = 0;
  1314. static Sg_device *
  1315. sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
  1316. {
  1317. struct request_queue *q = scsidp->request_queue;
  1318. Sg_device *sdp;
  1319. unsigned long iflags;
  1320. int error;
  1321. u32 k;
  1322. sdp = kzalloc(sizeof(Sg_device), GFP_KERNEL);
  1323. if (!sdp) {
  1324. sdev_printk(KERN_WARNING, scsidp, "%s: kmalloc Sg_device "
  1325. "failure\n", __func__);
  1326. return ERR_PTR(-ENOMEM);
  1327. }
  1328. idr_preload(GFP_KERNEL);
  1329. write_lock_irqsave(&sg_index_lock, iflags);
  1330. error = idr_alloc(&sg_index_idr, sdp, 0, SG_MAX_DEVS, GFP_NOWAIT);
  1331. if (error < 0) {
  1332. if (error == -ENOSPC) {
  1333. sdev_printk(KERN_WARNING, scsidp,
  1334. "Unable to attach sg device type=%d, minor number exceeds %d\n",
  1335. scsidp->type, SG_MAX_DEVS - 1);
  1336. error = -ENODEV;
  1337. } else {
  1338. sdev_printk(KERN_WARNING, scsidp, "%s: idr "
  1339. "allocation Sg_device failure: %d\n",
  1340. __func__, error);
  1341. }
  1342. goto out_unlock;
  1343. }
  1344. k = error;
  1345. SCSI_LOG_TIMEOUT(3, sdev_printk(KERN_INFO, scsidp,
  1346. "sg_alloc: dev=%d \n", k));
  1347. sprintf(disk->disk_name, "sg%d", k);
  1348. disk->first_minor = k;
  1349. sdp->disk = disk;
  1350. sdp->device = scsidp;
  1351. mutex_init(&sdp->open_rel_lock);
  1352. INIT_LIST_HEAD(&sdp->sfds);
  1353. init_waitqueue_head(&sdp->open_wait);
  1354. atomic_set(&sdp->detaching, 0);
  1355. rwlock_init(&sdp->sfd_lock);
  1356. sdp->sg_tablesize = queue_max_segments(q);
  1357. sdp->index = k;
  1358. kref_init(&sdp->d_ref);
  1359. error = 0;
  1360. out_unlock:
  1361. write_unlock_irqrestore(&sg_index_lock, iflags);
  1362. idr_preload_end();
  1363. if (error) {
  1364. kfree(sdp);
  1365. return ERR_PTR(error);
  1366. }
  1367. return sdp;
  1368. }
  1369. static int
  1370. sg_add_device(struct device *cl_dev, struct class_interface *cl_intf)
  1371. {
  1372. struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
  1373. struct gendisk *disk;
  1374. Sg_device *sdp = NULL;
  1375. struct cdev * cdev = NULL;
  1376. int error;
  1377. unsigned long iflags;
  1378. disk = alloc_disk(1);
  1379. if (!disk) {
  1380. pr_warn("%s: alloc_disk failed\n", __func__);
  1381. return -ENOMEM;
  1382. }
  1383. disk->major = SCSI_GENERIC_MAJOR;
  1384. error = -ENOMEM;
  1385. cdev = cdev_alloc();
  1386. if (!cdev) {
  1387. pr_warn("%s: cdev_alloc failed\n", __func__);
  1388. goto out;
  1389. }
  1390. cdev->owner = THIS_MODULE;
  1391. cdev->ops = &sg_fops;
  1392. sdp = sg_alloc(disk, scsidp);
  1393. if (IS_ERR(sdp)) {
  1394. pr_warn("%s: sg_alloc failed\n", __func__);
  1395. error = PTR_ERR(sdp);
  1396. goto out;
  1397. }
  1398. error = cdev_add(cdev, MKDEV(SCSI_GENERIC_MAJOR, sdp->index), 1);
  1399. if (error)
  1400. goto cdev_add_err;
  1401. sdp->cdev = cdev;
  1402. if (sg_sysfs_valid) {
  1403. struct device *sg_class_member;
  1404. sg_class_member = device_create(sg_sysfs_class, cl_dev->parent,
  1405. MKDEV(SCSI_GENERIC_MAJOR,
  1406. sdp->index),
  1407. sdp, "%s", disk->disk_name);
  1408. if (IS_ERR(sg_class_member)) {
  1409. pr_err("%s: device_create failed\n", __func__);
  1410. error = PTR_ERR(sg_class_member);
  1411. goto cdev_add_err;
  1412. }
  1413. error = sysfs_create_link(&scsidp->sdev_gendev.kobj,
  1414. &sg_class_member->kobj, "generic");
  1415. if (error)
  1416. pr_err("%s: unable to make symlink 'generic' back "
  1417. "to sg%d\n", __func__, sdp->index);
  1418. } else
  1419. pr_warn("%s: sg_sys Invalid\n", __func__);
  1420. sdev_printk(KERN_NOTICE, scsidp, "Attached scsi generic sg%d "
  1421. "type %d\n", sdp->index, scsidp->type);
  1422. dev_set_drvdata(cl_dev, sdp);
  1423. return 0;
  1424. cdev_add_err:
  1425. write_lock_irqsave(&sg_index_lock, iflags);
  1426. idr_remove(&sg_index_idr, sdp->index);
  1427. write_unlock_irqrestore(&sg_index_lock, iflags);
  1428. kfree(sdp);
  1429. out:
  1430. put_disk(disk);
  1431. if (cdev)
  1432. cdev_del(cdev);
  1433. return error;
  1434. }
  1435. static void
  1436. sg_device_destroy(struct kref *kref)
  1437. {
  1438. struct sg_device *sdp = container_of(kref, struct sg_device, d_ref);
  1439. unsigned long flags;
  1440. /* CAUTION! Note that the device can still be found via idr_find()
  1441. * even though the refcount is 0. Therefore, do idr_remove() BEFORE
  1442. * any other cleanup.
  1443. */
  1444. write_lock_irqsave(&sg_index_lock, flags);
  1445. idr_remove(&sg_index_idr, sdp->index);
  1446. write_unlock_irqrestore(&sg_index_lock, flags);
  1447. SCSI_LOG_TIMEOUT(3,
  1448. sg_printk(KERN_INFO, sdp, "sg_device_destroy\n"));
  1449. put_disk(sdp->disk);
  1450. kfree(sdp);
  1451. }
  1452. static void
  1453. sg_remove_device(struct device *cl_dev, struct class_interface *cl_intf)
  1454. {
  1455. struct scsi_device *scsidp = to_scsi_device(cl_dev->parent);
  1456. Sg_device *sdp = dev_get_drvdata(cl_dev);
  1457. unsigned long iflags;
  1458. Sg_fd *sfp;
  1459. int val;
  1460. if (!sdp)
  1461. return;
  1462. /* want sdp->detaching non-zero as soon as possible */
  1463. val = atomic_inc_return(&sdp->detaching);
  1464. if (val > 1)
  1465. return; /* only want to do following once per device */
  1466. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
  1467. "%s\n", __func__));
  1468. read_lock_irqsave(&sdp->sfd_lock, iflags);
  1469. list_for_each_entry(sfp, &sdp->sfds, sfd_siblings) {
  1470. wake_up_interruptible_all(&sfp->read_wait);
  1471. kill_fasync(&sfp->async_qp, SIGPOLL, POLL_HUP);
  1472. }
  1473. wake_up_interruptible_all(&sdp->open_wait);
  1474. read_unlock_irqrestore(&sdp->sfd_lock, iflags);
  1475. sysfs_remove_link(&scsidp->sdev_gendev.kobj, "generic");
  1476. device_destroy(sg_sysfs_class, MKDEV(SCSI_GENERIC_MAJOR, sdp->index));
  1477. cdev_del(sdp->cdev);
  1478. sdp->cdev = NULL;
  1479. kref_put(&sdp->d_ref, sg_device_destroy);
  1480. }
  1481. module_param_named(scatter_elem_sz, scatter_elem_sz, int, S_IRUGO | S_IWUSR);
  1482. module_param_named(def_reserved_size, def_reserved_size, int,
  1483. S_IRUGO | S_IWUSR);
  1484. module_param_named(allow_dio, sg_allow_dio, int, S_IRUGO | S_IWUSR);
  1485. MODULE_AUTHOR("Douglas Gilbert");
  1486. MODULE_DESCRIPTION("SCSI generic (sg) driver");
  1487. MODULE_LICENSE("GPL");
  1488. MODULE_VERSION(SG_VERSION_STR);
  1489. MODULE_ALIAS_CHARDEV_MAJOR(SCSI_GENERIC_MAJOR);
  1490. MODULE_PARM_DESC(scatter_elem_sz, "scatter gather element "
  1491. "size (default: max(SG_SCATTER_SZ, PAGE_SIZE))");
  1492. MODULE_PARM_DESC(def_reserved_size, "size of buffer reserved for each fd");
  1493. MODULE_PARM_DESC(allow_dio, "allow direct I/O (default: 0 (disallow))");
  1494. static int __init
  1495. init_sg(void)
  1496. {
  1497. int rc;
  1498. if (scatter_elem_sz < PAGE_SIZE) {
  1499. scatter_elem_sz = PAGE_SIZE;
  1500. scatter_elem_sz_prev = scatter_elem_sz;
  1501. }
  1502. if (def_reserved_size >= 0)
  1503. sg_big_buff = def_reserved_size;
  1504. else
  1505. def_reserved_size = sg_big_buff;
  1506. rc = register_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
  1507. SG_MAX_DEVS, "sg");
  1508. if (rc)
  1509. return rc;
  1510. sg_sysfs_class = class_create(THIS_MODULE, "scsi_generic");
  1511. if ( IS_ERR(sg_sysfs_class) ) {
  1512. rc = PTR_ERR(sg_sysfs_class);
  1513. goto err_out;
  1514. }
  1515. sg_sysfs_valid = 1;
  1516. rc = scsi_register_interface(&sg_interface);
  1517. if (0 == rc) {
  1518. #ifdef CONFIG_SCSI_PROC_FS
  1519. sg_proc_init();
  1520. #endif /* CONFIG_SCSI_PROC_FS */
  1521. return 0;
  1522. }
  1523. class_destroy(sg_sysfs_class);
  1524. err_out:
  1525. unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0), SG_MAX_DEVS);
  1526. return rc;
  1527. }
  1528. static void __exit
  1529. exit_sg(void)
  1530. {
  1531. #ifdef CONFIG_SCSI_PROC_FS
  1532. remove_proc_subtree("scsi/sg", NULL);
  1533. #endif /* CONFIG_SCSI_PROC_FS */
  1534. scsi_unregister_interface(&sg_interface);
  1535. class_destroy(sg_sysfs_class);
  1536. sg_sysfs_valid = 0;
  1537. unregister_chrdev_region(MKDEV(SCSI_GENERIC_MAJOR, 0),
  1538. SG_MAX_DEVS);
  1539. idr_destroy(&sg_index_idr);
  1540. }
  1541. static int
  1542. sg_start_req(Sg_request *srp, unsigned char *cmd)
  1543. {
  1544. int res;
  1545. struct request *rq;
  1546. struct scsi_request *req;
  1547. Sg_fd *sfp = srp->parentfp;
  1548. sg_io_hdr_t *hp = &srp->header;
  1549. int dxfer_len = (int) hp->dxfer_len;
  1550. int dxfer_dir = hp->dxfer_direction;
  1551. unsigned int iov_count = hp->iovec_count;
  1552. Sg_scatter_hold *req_schp = &srp->data;
  1553. Sg_scatter_hold *rsv_schp = &sfp->reserve;
  1554. struct request_queue *q = sfp->parentdp->device->request_queue;
  1555. struct rq_map_data *md, map_data;
  1556. int rw = hp->dxfer_direction == SG_DXFER_TO_DEV ? WRITE : READ;
  1557. unsigned char *long_cmdp = NULL;
  1558. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
  1559. "sg_start_req: dxfer_len=%d\n",
  1560. dxfer_len));
  1561. if (hp->cmd_len > BLK_MAX_CDB) {
  1562. long_cmdp = kzalloc(hp->cmd_len, GFP_KERNEL);
  1563. if (!long_cmdp)
  1564. return -ENOMEM;
  1565. }
  1566. /*
  1567. * NOTE
  1568. *
  1569. * With scsi-mq enabled, there are a fixed number of preallocated
  1570. * requests equal in number to shost->can_queue. If all of the
  1571. * preallocated requests are already in use, then blk_get_request()
  1572. * will sleep until an active command completes, freeing up a request.
  1573. * Although waiting in an asynchronous interface is less than ideal, we
  1574. * do not want to use BLK_MQ_REQ_NOWAIT here because userspace might
  1575. * not expect an EWOULDBLOCK from this condition.
  1576. */
  1577. rq = blk_get_request(q, hp->dxfer_direction == SG_DXFER_TO_DEV ?
  1578. REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
  1579. if (IS_ERR(rq)) {
  1580. kfree(long_cmdp);
  1581. return PTR_ERR(rq);
  1582. }
  1583. req = scsi_req(rq);
  1584. if (hp->cmd_len > BLK_MAX_CDB)
  1585. req->cmd = long_cmdp;
  1586. memcpy(req->cmd, cmd, hp->cmd_len);
  1587. req->cmd_len = hp->cmd_len;
  1588. srp->rq = rq;
  1589. rq->end_io_data = srp;
  1590. req->retries = SG_DEFAULT_RETRIES;
  1591. if ((dxfer_len <= 0) || (dxfer_dir == SG_DXFER_NONE))
  1592. return 0;
  1593. if (sg_allow_dio && hp->flags & SG_FLAG_DIRECT_IO &&
  1594. dxfer_dir != SG_DXFER_UNKNOWN && !iov_count &&
  1595. !sfp->parentdp->device->host->unchecked_isa_dma &&
  1596. blk_rq_aligned(q, (unsigned long)hp->dxferp, dxfer_len))
  1597. md = NULL;
  1598. else
  1599. md = &map_data;
  1600. if (md) {
  1601. mutex_lock(&sfp->f_mutex);
  1602. if (dxfer_len <= rsv_schp->bufflen &&
  1603. !sfp->res_in_use) {
  1604. sfp->res_in_use = 1;
  1605. sg_link_reserve(sfp, srp, dxfer_len);
  1606. } else if (hp->flags & SG_FLAG_MMAP_IO) {
  1607. res = -EBUSY; /* sfp->res_in_use == 1 */
  1608. if (dxfer_len > rsv_schp->bufflen)
  1609. res = -ENOMEM;
  1610. mutex_unlock(&sfp->f_mutex);
  1611. return res;
  1612. } else {
  1613. res = sg_build_indirect(req_schp, sfp, dxfer_len);
  1614. if (res) {
  1615. mutex_unlock(&sfp->f_mutex);
  1616. return res;
  1617. }
  1618. }
  1619. mutex_unlock(&sfp->f_mutex);
  1620. md->pages = req_schp->pages;
  1621. md->page_order = req_schp->page_order;
  1622. md->nr_entries = req_schp->k_use_sg;
  1623. md->offset = 0;
  1624. md->null_mapped = hp->dxferp ? 0 : 1;
  1625. if (dxfer_dir == SG_DXFER_TO_FROM_DEV)
  1626. md->from_user = 1;
  1627. else
  1628. md->from_user = 0;
  1629. }
  1630. if (iov_count) {
  1631. struct iovec *iov = NULL;
  1632. struct iov_iter i;
  1633. res = import_iovec(rw, hp->dxferp, iov_count, 0, &iov, &i);
  1634. if (res < 0)
  1635. return res;
  1636. iov_iter_truncate(&i, hp->dxfer_len);
  1637. if (!iov_iter_count(&i)) {
  1638. kfree(iov);
  1639. return -EINVAL;
  1640. }
  1641. res = blk_rq_map_user_iov(q, rq, md, &i, GFP_ATOMIC);
  1642. kfree(iov);
  1643. } else
  1644. res = blk_rq_map_user(q, rq, md, hp->dxferp,
  1645. hp->dxfer_len, GFP_ATOMIC);
  1646. if (!res) {
  1647. srp->bio = rq->bio;
  1648. if (!md) {
  1649. req_schp->dio_in_use = 1;
  1650. hp->info |= SG_INFO_DIRECT_IO;
  1651. }
  1652. }
  1653. return res;
  1654. }
  1655. static int
  1656. sg_finish_rem_req(Sg_request *srp)
  1657. {
  1658. int ret = 0;
  1659. Sg_fd *sfp = srp->parentfp;
  1660. Sg_scatter_hold *req_schp = &srp->data;
  1661. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
  1662. "sg_finish_rem_req: res_used=%d\n",
  1663. (int) srp->res_used));
  1664. if (srp->bio)
  1665. ret = blk_rq_unmap_user(srp->bio);
  1666. if (srp->rq) {
  1667. scsi_req_free_cmd(scsi_req(srp->rq));
  1668. blk_put_request(srp->rq);
  1669. }
  1670. if (srp->res_used)
  1671. sg_unlink_reserve(sfp, srp);
  1672. else
  1673. sg_remove_scat(sfp, req_schp);
  1674. return ret;
  1675. }
  1676. static int
  1677. sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp, int tablesize)
  1678. {
  1679. int sg_bufflen = tablesize * sizeof(struct page *);
  1680. gfp_t gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
  1681. schp->pages = kzalloc(sg_bufflen, gfp_flags);
  1682. if (!schp->pages)
  1683. return -ENOMEM;
  1684. schp->sglist_len = sg_bufflen;
  1685. return tablesize; /* number of scat_gath elements allocated */
  1686. }
  1687. static int
  1688. sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
  1689. {
  1690. int ret_sz = 0, i, k, rem_sz, num, mx_sc_elems;
  1691. int sg_tablesize = sfp->parentdp->sg_tablesize;
  1692. int blk_size = buff_size, order;
  1693. gfp_t gfp_mask = GFP_ATOMIC | __GFP_COMP | __GFP_NOWARN | __GFP_ZERO;
  1694. struct sg_device *sdp = sfp->parentdp;
  1695. if (blk_size < 0)
  1696. return -EFAULT;
  1697. if (0 == blk_size)
  1698. ++blk_size; /* don't know why */
  1699. /* round request up to next highest SG_SECTOR_SZ byte boundary */
  1700. blk_size = ALIGN(blk_size, SG_SECTOR_SZ);
  1701. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
  1702. "sg_build_indirect: buff_size=%d, blk_size=%d\n",
  1703. buff_size, blk_size));
  1704. /* N.B. ret_sz carried into this block ... */
  1705. mx_sc_elems = sg_build_sgat(schp, sfp, sg_tablesize);
  1706. if (mx_sc_elems < 0)
  1707. return mx_sc_elems; /* most likely -ENOMEM */
  1708. num = scatter_elem_sz;
  1709. if (unlikely(num != scatter_elem_sz_prev)) {
  1710. if (num < PAGE_SIZE) {
  1711. scatter_elem_sz = PAGE_SIZE;
  1712. scatter_elem_sz_prev = PAGE_SIZE;
  1713. } else
  1714. scatter_elem_sz_prev = num;
  1715. }
  1716. if (sdp->device->host->unchecked_isa_dma)
  1717. gfp_mask |= GFP_DMA;
  1718. order = get_order(num);
  1719. retry:
  1720. ret_sz = 1 << (PAGE_SHIFT + order);
  1721. for (k = 0, rem_sz = blk_size; rem_sz > 0 && k < mx_sc_elems;
  1722. k++, rem_sz -= ret_sz) {
  1723. num = (rem_sz > scatter_elem_sz_prev) ?
  1724. scatter_elem_sz_prev : rem_sz;
  1725. schp->pages[k] = alloc_pages(gfp_mask, order);
  1726. if (!schp->pages[k])
  1727. goto out;
  1728. if (num == scatter_elem_sz_prev) {
  1729. if (unlikely(ret_sz > scatter_elem_sz_prev)) {
  1730. scatter_elem_sz = ret_sz;
  1731. scatter_elem_sz_prev = ret_sz;
  1732. }
  1733. }
  1734. SCSI_LOG_TIMEOUT(5, sg_printk(KERN_INFO, sfp->parentdp,
  1735. "sg_build_indirect: k=%d, num=%d, ret_sz=%d\n",
  1736. k, num, ret_sz));
  1737. } /* end of for loop */
  1738. schp->page_order = order;
  1739. schp->k_use_sg = k;
  1740. SCSI_LOG_TIMEOUT(5, sg_printk(KERN_INFO, sfp->parentdp,
  1741. "sg_build_indirect: k_use_sg=%d, rem_sz=%d\n",
  1742. k, rem_sz));
  1743. schp->bufflen = blk_size;
  1744. if (rem_sz > 0) /* must have failed */
  1745. return -ENOMEM;
  1746. return 0;
  1747. out:
  1748. for (i = 0; i < k; i++)
  1749. __free_pages(schp->pages[i], order);
  1750. if (--order >= 0)
  1751. goto retry;
  1752. return -ENOMEM;
  1753. }
  1754. static void
  1755. sg_remove_scat(Sg_fd * sfp, Sg_scatter_hold * schp)
  1756. {
  1757. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
  1758. "sg_remove_scat: k_use_sg=%d\n", schp->k_use_sg));
  1759. if (schp->pages && schp->sglist_len > 0) {
  1760. if (!schp->dio_in_use) {
  1761. int k;
  1762. for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
  1763. SCSI_LOG_TIMEOUT(5,
  1764. sg_printk(KERN_INFO, sfp->parentdp,
  1765. "sg_remove_scat: k=%d, pg=0x%p\n",
  1766. k, schp->pages[k]));
  1767. __free_pages(schp->pages[k], schp->page_order);
  1768. }
  1769. kfree(schp->pages);
  1770. }
  1771. }
  1772. memset(schp, 0, sizeof (*schp));
  1773. }
  1774. static int
  1775. sg_read_oxfer(Sg_request * srp, char __user *outp, int num_read_xfer)
  1776. {
  1777. Sg_scatter_hold *schp = &srp->data;
  1778. int k, num;
  1779. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, srp->parentfp->parentdp,
  1780. "sg_read_oxfer: num_read_xfer=%d\n",
  1781. num_read_xfer));
  1782. if ((!outp) || (num_read_xfer <= 0))
  1783. return 0;
  1784. num = 1 << (PAGE_SHIFT + schp->page_order);
  1785. for (k = 0; k < schp->k_use_sg && schp->pages[k]; k++) {
  1786. if (num > num_read_xfer) {
  1787. if (__copy_to_user(outp, page_address(schp->pages[k]),
  1788. num_read_xfer))
  1789. return -EFAULT;
  1790. break;
  1791. } else {
  1792. if (__copy_to_user(outp, page_address(schp->pages[k]),
  1793. num))
  1794. return -EFAULT;
  1795. num_read_xfer -= num;
  1796. if (num_read_xfer <= 0)
  1797. break;
  1798. outp += num;
  1799. }
  1800. }
  1801. return 0;
  1802. }
  1803. static void
  1804. sg_build_reserve(Sg_fd * sfp, int req_size)
  1805. {
  1806. Sg_scatter_hold *schp = &sfp->reserve;
  1807. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
  1808. "sg_build_reserve: req_size=%d\n", req_size));
  1809. do {
  1810. if (req_size < PAGE_SIZE)
  1811. req_size = PAGE_SIZE;
  1812. if (0 == sg_build_indirect(schp, sfp, req_size))
  1813. return;
  1814. else
  1815. sg_remove_scat(sfp, schp);
  1816. req_size >>= 1; /* divide by 2 */
  1817. } while (req_size > (PAGE_SIZE / 2));
  1818. }
  1819. static void
  1820. sg_link_reserve(Sg_fd * sfp, Sg_request * srp, int size)
  1821. {
  1822. Sg_scatter_hold *req_schp = &srp->data;
  1823. Sg_scatter_hold *rsv_schp = &sfp->reserve;
  1824. int k, num, rem;
  1825. srp->res_used = 1;
  1826. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
  1827. "sg_link_reserve: size=%d\n", size));
  1828. rem = size;
  1829. num = 1 << (PAGE_SHIFT + rsv_schp->page_order);
  1830. for (k = 0; k < rsv_schp->k_use_sg; k++) {
  1831. if (rem <= num) {
  1832. req_schp->k_use_sg = k + 1;
  1833. req_schp->sglist_len = rsv_schp->sglist_len;
  1834. req_schp->pages = rsv_schp->pages;
  1835. req_schp->bufflen = size;
  1836. req_schp->page_order = rsv_schp->page_order;
  1837. break;
  1838. } else
  1839. rem -= num;
  1840. }
  1841. if (k >= rsv_schp->k_use_sg)
  1842. SCSI_LOG_TIMEOUT(1, sg_printk(KERN_INFO, sfp->parentdp,
  1843. "sg_link_reserve: BAD size\n"));
  1844. }
  1845. static void
  1846. sg_unlink_reserve(Sg_fd * sfp, Sg_request * srp)
  1847. {
  1848. Sg_scatter_hold *req_schp = &srp->data;
  1849. SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, srp->parentfp->parentdp,
  1850. "sg_unlink_reserve: req->k_use_sg=%d\n",
  1851. (int) req_schp->k_use_sg));
  1852. req_schp->k_use_sg = 0;
  1853. req_schp->bufflen = 0;
  1854. req_schp->pages = NULL;
  1855. req_schp->page_order = 0;
  1856. req_schp->sglist_len = 0;
  1857. srp->res_used = 0;
  1858. /* Called without mutex lock to avoid deadlock */
  1859. sfp->res_in_use = 0;
  1860. }
  1861. static Sg_request *
  1862. sg_get_rq_mark(Sg_fd * sfp, int pack_id)
  1863. {
  1864. Sg_request *resp;
  1865. unsigned long iflags;
  1866. write_lock_irqsave(&sfp->rq_list_lock, iflags);
  1867. list_for_each_entry(resp, &sfp->rq_list, entry) {
  1868. /* look for requests that are ready + not SG_IO owned */
  1869. if ((1 == resp->done) && (!resp->sg_io_owned) &&
  1870. ((-1 == pack_id) || (resp->header.pack_id == pack_id))) {
  1871. resp->done = 2; /* guard against other readers */
  1872. write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  1873. return resp;
  1874. }
  1875. }
  1876. write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  1877. return NULL;
  1878. }
  1879. /* always adds to end of list */
  1880. static Sg_request *
  1881. sg_add_request(Sg_fd * sfp)
  1882. {
  1883. int k;
  1884. unsigned long iflags;
  1885. Sg_request *rp = sfp->req_arr;
  1886. write_lock_irqsave(&sfp->rq_list_lock, iflags);
  1887. if (!list_empty(&sfp->rq_list)) {
  1888. if (!sfp->cmd_q)
  1889. goto out_unlock;
  1890. for (k = 0; k < SG_MAX_QUEUE; ++k, ++rp) {
  1891. if (!rp->parentfp)
  1892. break;
  1893. }
  1894. if (k >= SG_MAX_QUEUE)
  1895. goto out_unlock;
  1896. }
  1897. memset(rp, 0, sizeof (Sg_request));
  1898. rp->parentfp = sfp;
  1899. rp->header.duration = jiffies_to_msecs(jiffies);
  1900. list_add_tail(&rp->entry, &sfp->rq_list);
  1901. write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  1902. return rp;
  1903. out_unlock:
  1904. write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  1905. return NULL;
  1906. }
  1907. /* Return of 1 for found; 0 for not found */
  1908. static int
  1909. sg_remove_request(Sg_fd * sfp, Sg_request * srp)
  1910. {
  1911. unsigned long iflags;
  1912. int res = 0;
  1913. if (!sfp || !srp || list_empty(&sfp->rq_list))
  1914. return res;
  1915. write_lock_irqsave(&sfp->rq_list_lock, iflags);
  1916. if (!list_empty(&srp->entry)) {
  1917. list_del(&srp->entry);
  1918. srp->parentfp = NULL;
  1919. res = 1;
  1920. }
  1921. write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  1922. return res;
  1923. }
  1924. static Sg_fd *
  1925. sg_add_sfp(Sg_device * sdp)
  1926. {
  1927. Sg_fd *sfp;
  1928. unsigned long iflags;
  1929. int bufflen;
  1930. sfp = kzalloc(sizeof(*sfp), GFP_ATOMIC | __GFP_NOWARN);
  1931. if (!sfp)
  1932. return ERR_PTR(-ENOMEM);
  1933. init_waitqueue_head(&sfp->read_wait);
  1934. rwlock_init(&sfp->rq_list_lock);
  1935. INIT_LIST_HEAD(&sfp->rq_list);
  1936. kref_init(&sfp->f_ref);
  1937. mutex_init(&sfp->f_mutex);
  1938. sfp->timeout = SG_DEFAULT_TIMEOUT;
  1939. sfp->timeout_user = SG_DEFAULT_TIMEOUT_USER;
  1940. sfp->force_packid = SG_DEF_FORCE_PACK_ID;
  1941. sfp->cmd_q = SG_DEF_COMMAND_Q;
  1942. sfp->keep_orphan = SG_DEF_KEEP_ORPHAN;
  1943. sfp->parentdp = sdp;
  1944. write_lock_irqsave(&sdp->sfd_lock, iflags);
  1945. if (atomic_read(&sdp->detaching)) {
  1946. write_unlock_irqrestore(&sdp->sfd_lock, iflags);
  1947. kfree(sfp);
  1948. return ERR_PTR(-ENODEV);
  1949. }
  1950. list_add_tail(&sfp->sfd_siblings, &sdp->sfds);
  1951. write_unlock_irqrestore(&sdp->sfd_lock, iflags);
  1952. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
  1953. "sg_add_sfp: sfp=0x%p\n", sfp));
  1954. if (unlikely(sg_big_buff != def_reserved_size))
  1955. sg_big_buff = def_reserved_size;
  1956. bufflen = min_t(int, sg_big_buff,
  1957. max_sectors_bytes(sdp->device->request_queue));
  1958. sg_build_reserve(sfp, bufflen);
  1959. SCSI_LOG_TIMEOUT(3, sg_printk(KERN_INFO, sdp,
  1960. "sg_add_sfp: bufflen=%d, k_use_sg=%d\n",
  1961. sfp->reserve.bufflen,
  1962. sfp->reserve.k_use_sg));
  1963. kref_get(&sdp->d_ref);
  1964. __module_get(THIS_MODULE);
  1965. return sfp;
  1966. }
  1967. static void
  1968. sg_remove_sfp_usercontext(struct work_struct *work)
  1969. {
  1970. struct sg_fd *sfp = container_of(work, struct sg_fd, ew.work);
  1971. struct sg_device *sdp = sfp->parentdp;
  1972. Sg_request *srp;
  1973. unsigned long iflags;
  1974. /* Cleanup any responses which were never read(). */
  1975. write_lock_irqsave(&sfp->rq_list_lock, iflags);
  1976. while (!list_empty(&sfp->rq_list)) {
  1977. srp = list_first_entry(&sfp->rq_list, Sg_request, entry);
  1978. sg_finish_rem_req(srp);
  1979. list_del(&srp->entry);
  1980. srp->parentfp = NULL;
  1981. }
  1982. write_unlock_irqrestore(&sfp->rq_list_lock, iflags);
  1983. if (sfp->reserve.bufflen > 0) {
  1984. SCSI_LOG_TIMEOUT(6, sg_printk(KERN_INFO, sdp,
  1985. "sg_remove_sfp: bufflen=%d, k_use_sg=%d\n",
  1986. (int) sfp->reserve.bufflen,
  1987. (int) sfp->reserve.k_use_sg));
  1988. sg_remove_scat(sfp, &sfp->reserve);
  1989. }
  1990. SCSI_LOG_TIMEOUT(6, sg_printk(KERN_INFO, sdp,
  1991. "sg_remove_sfp: sfp=0x%p\n", sfp));
  1992. kfree(sfp);
  1993. scsi_device_put(sdp->device);
  1994. kref_put(&sdp->d_ref, sg_device_destroy);
  1995. module_put(THIS_MODULE);
  1996. }
  1997. static void
  1998. sg_remove_sfp(struct kref *kref)
  1999. {
  2000. struct sg_fd *sfp = container_of(kref, struct sg_fd, f_ref);
  2001. struct sg_device *sdp = sfp->parentdp;
  2002. unsigned long iflags;
  2003. write_lock_irqsave(&sdp->sfd_lock, iflags);
  2004. list_del(&sfp->sfd_siblings);
  2005. write_unlock_irqrestore(&sdp->sfd_lock, iflags);
  2006. INIT_WORK(&sfp->ew.work, sg_remove_sfp_usercontext);
  2007. schedule_work(&sfp->ew.work);
  2008. }
  2009. #ifdef CONFIG_SCSI_PROC_FS
  2010. static int
  2011. sg_idr_max_id(int id, void *p, void *data)
  2012. {
  2013. int *k = data;
  2014. if (*k < id)
  2015. *k = id;
  2016. return 0;
  2017. }
  2018. static int
  2019. sg_last_dev(void)
  2020. {
  2021. int k = -1;
  2022. unsigned long iflags;
  2023. read_lock_irqsave(&sg_index_lock, iflags);
  2024. idr_for_each(&sg_index_idr, sg_idr_max_id, &k);
  2025. read_unlock_irqrestore(&sg_index_lock, iflags);
  2026. return k + 1; /* origin 1 */
  2027. }
  2028. #endif
  2029. /* must be called with sg_index_lock held */
  2030. static Sg_device *sg_lookup_dev(int dev)
  2031. {
  2032. return idr_find(&sg_index_idr, dev);
  2033. }
  2034. static Sg_device *
  2035. sg_get_dev(int dev)
  2036. {
  2037. struct sg_device *sdp;
  2038. unsigned long flags;
  2039. read_lock_irqsave(&sg_index_lock, flags);
  2040. sdp = sg_lookup_dev(dev);
  2041. if (!sdp)
  2042. sdp = ERR_PTR(-ENXIO);
  2043. else if (atomic_read(&sdp->detaching)) {
  2044. /* If sdp->detaching, then the refcount may already be 0, in
  2045. * which case it would be a bug to do kref_get().
  2046. */
  2047. sdp = ERR_PTR(-ENODEV);
  2048. } else
  2049. kref_get(&sdp->d_ref);
  2050. read_unlock_irqrestore(&sg_index_lock, flags);
  2051. return sdp;
  2052. }
  2053. #ifdef CONFIG_SCSI_PROC_FS
  2054. static int sg_proc_seq_show_int(struct seq_file *s, void *v);
  2055. static int sg_proc_single_open_adio(struct inode *inode, struct file *file);
  2056. static ssize_t sg_proc_write_adio(struct file *filp, const char __user *buffer,
  2057. size_t count, loff_t *off);
  2058. static const struct file_operations adio_fops = {
  2059. .owner = THIS_MODULE,
  2060. .open = sg_proc_single_open_adio,
  2061. .read = seq_read,
  2062. .llseek = seq_lseek,
  2063. .write = sg_proc_write_adio,
  2064. .release = single_release,
  2065. };
  2066. static int sg_proc_single_open_dressz(struct inode *inode, struct file *file);
  2067. static ssize_t sg_proc_write_dressz(struct file *filp,
  2068. const char __user *buffer, size_t count, loff_t *off);
  2069. static const struct file_operations dressz_fops = {
  2070. .owner = THIS_MODULE,
  2071. .open = sg_proc_single_open_dressz,
  2072. .read = seq_read,
  2073. .llseek = seq_lseek,
  2074. .write = sg_proc_write_dressz,
  2075. .release = single_release,
  2076. };
  2077. static int sg_proc_seq_show_version(struct seq_file *s, void *v);
  2078. static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v);
  2079. static int sg_proc_seq_show_dev(struct seq_file *s, void *v);
  2080. static void * dev_seq_start(struct seq_file *s, loff_t *pos);
  2081. static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos);
  2082. static void dev_seq_stop(struct seq_file *s, void *v);
  2083. static const struct seq_operations dev_seq_ops = {
  2084. .start = dev_seq_start,
  2085. .next = dev_seq_next,
  2086. .stop = dev_seq_stop,
  2087. .show = sg_proc_seq_show_dev,
  2088. };
  2089. static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v);
  2090. static const struct seq_operations devstrs_seq_ops = {
  2091. .start = dev_seq_start,
  2092. .next = dev_seq_next,
  2093. .stop = dev_seq_stop,
  2094. .show = sg_proc_seq_show_devstrs,
  2095. };
  2096. static int sg_proc_seq_show_debug(struct seq_file *s, void *v);
  2097. static const struct seq_operations debug_seq_ops = {
  2098. .start = dev_seq_start,
  2099. .next = dev_seq_next,
  2100. .stop = dev_seq_stop,
  2101. .show = sg_proc_seq_show_debug,
  2102. };
  2103. static int
  2104. sg_proc_init(void)
  2105. {
  2106. struct proc_dir_entry *p;
  2107. p = proc_mkdir("scsi/sg", NULL);
  2108. if (!p)
  2109. return 1;
  2110. proc_create("allow_dio", S_IRUGO | S_IWUSR, p, &adio_fops);
  2111. proc_create_seq("debug", S_IRUGO, p, &debug_seq_ops);
  2112. proc_create("def_reserved_size", S_IRUGO | S_IWUSR, p, &dressz_fops);
  2113. proc_create_single("device_hdr", S_IRUGO, p, sg_proc_seq_show_devhdr);
  2114. proc_create_seq("devices", S_IRUGO, p, &dev_seq_ops);
  2115. proc_create_seq("device_strs", S_IRUGO, p, &devstrs_seq_ops);
  2116. proc_create_single("version", S_IRUGO, p, sg_proc_seq_show_version);
  2117. return 0;
  2118. }
  2119. static int sg_proc_seq_show_int(struct seq_file *s, void *v)
  2120. {
  2121. seq_printf(s, "%d\n", *((int *)s->private));
  2122. return 0;
  2123. }
  2124. static int sg_proc_single_open_adio(struct inode *inode, struct file *file)
  2125. {
  2126. return single_open(file, sg_proc_seq_show_int, &sg_allow_dio);
  2127. }
  2128. static ssize_t
  2129. sg_proc_write_adio(struct file *filp, const char __user *buffer,
  2130. size_t count, loff_t *off)
  2131. {
  2132. int err;
  2133. unsigned long num;
  2134. if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
  2135. return -EACCES;
  2136. err = kstrtoul_from_user(buffer, count, 0, &num);
  2137. if (err)
  2138. return err;
  2139. sg_allow_dio = num ? 1 : 0;
  2140. return count;
  2141. }
  2142. static int sg_proc_single_open_dressz(struct inode *inode, struct file *file)
  2143. {
  2144. return single_open(file, sg_proc_seq_show_int, &sg_big_buff);
  2145. }
  2146. static ssize_t
  2147. sg_proc_write_dressz(struct file *filp, const char __user *buffer,
  2148. size_t count, loff_t *off)
  2149. {
  2150. int err;
  2151. unsigned long k = ULONG_MAX;
  2152. if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
  2153. return -EACCES;
  2154. err = kstrtoul_from_user(buffer, count, 0, &k);
  2155. if (err)
  2156. return err;
  2157. if (k <= 1048576) { /* limit "big buff" to 1 MB */
  2158. sg_big_buff = k;
  2159. return count;
  2160. }
  2161. return -ERANGE;
  2162. }
  2163. static int sg_proc_seq_show_version(struct seq_file *s, void *v)
  2164. {
  2165. seq_printf(s, "%d\t%s [%s]\n", sg_version_num, SG_VERSION_STR,
  2166. sg_version_date);
  2167. return 0;
  2168. }
  2169. static int sg_proc_seq_show_devhdr(struct seq_file *s, void *v)
  2170. {
  2171. seq_puts(s, "host\tchan\tid\tlun\ttype\topens\tqdepth\tbusy\tonline\n");
  2172. return 0;
  2173. }
  2174. struct sg_proc_deviter {
  2175. loff_t index;
  2176. size_t max;
  2177. };
  2178. static void * dev_seq_start(struct seq_file *s, loff_t *pos)
  2179. {
  2180. struct sg_proc_deviter * it = kmalloc(sizeof(*it), GFP_KERNEL);
  2181. s->private = it;
  2182. if (! it)
  2183. return NULL;
  2184. it->index = *pos;
  2185. it->max = sg_last_dev();
  2186. if (it->index >= it->max)
  2187. return NULL;
  2188. return it;
  2189. }
  2190. static void * dev_seq_next(struct seq_file *s, void *v, loff_t *pos)
  2191. {
  2192. struct sg_proc_deviter * it = s->private;
  2193. *pos = ++it->index;
  2194. return (it->index < it->max) ? it : NULL;
  2195. }
  2196. static void dev_seq_stop(struct seq_file *s, void *v)
  2197. {
  2198. kfree(s->private);
  2199. }
  2200. static int sg_proc_seq_show_dev(struct seq_file *s, void *v)
  2201. {
  2202. struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
  2203. Sg_device *sdp;
  2204. struct scsi_device *scsidp;
  2205. unsigned long iflags;
  2206. read_lock_irqsave(&sg_index_lock, iflags);
  2207. sdp = it ? sg_lookup_dev(it->index) : NULL;
  2208. if ((NULL == sdp) || (NULL == sdp->device) ||
  2209. (atomic_read(&sdp->detaching)))
  2210. seq_puts(s, "-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\n");
  2211. else {
  2212. scsidp = sdp->device;
  2213. seq_printf(s, "%d\t%d\t%d\t%llu\t%d\t%d\t%d\t%d\t%d\n",
  2214. scsidp->host->host_no, scsidp->channel,
  2215. scsidp->id, scsidp->lun, (int) scsidp->type,
  2216. 1,
  2217. (int) scsidp->queue_depth,
  2218. (int) atomic_read(&scsidp->device_busy),
  2219. (int) scsi_device_online(scsidp));
  2220. }
  2221. read_unlock_irqrestore(&sg_index_lock, iflags);
  2222. return 0;
  2223. }
  2224. static int sg_proc_seq_show_devstrs(struct seq_file *s, void *v)
  2225. {
  2226. struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
  2227. Sg_device *sdp;
  2228. struct scsi_device *scsidp;
  2229. unsigned long iflags;
  2230. read_lock_irqsave(&sg_index_lock, iflags);
  2231. sdp = it ? sg_lookup_dev(it->index) : NULL;
  2232. scsidp = sdp ? sdp->device : NULL;
  2233. if (sdp && scsidp && (!atomic_read(&sdp->detaching)))
  2234. seq_printf(s, "%8.8s\t%16.16s\t%4.4s\n",
  2235. scsidp->vendor, scsidp->model, scsidp->rev);
  2236. else
  2237. seq_puts(s, "<no active device>\n");
  2238. read_unlock_irqrestore(&sg_index_lock, iflags);
  2239. return 0;
  2240. }
  2241. /* must be called while holding sg_index_lock */
  2242. static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp)
  2243. {
  2244. int k, new_interface, blen, usg;
  2245. Sg_request *srp;
  2246. Sg_fd *fp;
  2247. const sg_io_hdr_t *hp;
  2248. const char * cp;
  2249. unsigned int ms;
  2250. k = 0;
  2251. list_for_each_entry(fp, &sdp->sfds, sfd_siblings) {
  2252. k++;
  2253. read_lock(&fp->rq_list_lock); /* irqs already disabled */
  2254. seq_printf(s, " FD(%d): timeout=%dms bufflen=%d "
  2255. "(res)sgat=%d low_dma=%d\n", k,
  2256. jiffies_to_msecs(fp->timeout),
  2257. fp->reserve.bufflen,
  2258. (int) fp->reserve.k_use_sg,
  2259. (int) sdp->device->host->unchecked_isa_dma);
  2260. seq_printf(s, " cmd_q=%d f_packid=%d k_orphan=%d closed=0\n",
  2261. (int) fp->cmd_q, (int) fp->force_packid,
  2262. (int) fp->keep_orphan);
  2263. list_for_each_entry(srp, &fp->rq_list, entry) {
  2264. hp = &srp->header;
  2265. new_interface = (hp->interface_id == '\0') ? 0 : 1;
  2266. if (srp->res_used) {
  2267. if (new_interface &&
  2268. (SG_FLAG_MMAP_IO & hp->flags))
  2269. cp = " mmap>> ";
  2270. else
  2271. cp = " rb>> ";
  2272. } else {
  2273. if (SG_INFO_DIRECT_IO_MASK & hp->info)
  2274. cp = " dio>> ";
  2275. else
  2276. cp = " ";
  2277. }
  2278. seq_puts(s, cp);
  2279. blen = srp->data.bufflen;
  2280. usg = srp->data.k_use_sg;
  2281. seq_puts(s, srp->done ?
  2282. ((1 == srp->done) ? "rcv:" : "fin:")
  2283. : "act:");
  2284. seq_printf(s, " id=%d blen=%d",
  2285. srp->header.pack_id, blen);
  2286. if (srp->done)
  2287. seq_printf(s, " dur=%d", hp->duration);
  2288. else {
  2289. ms = jiffies_to_msecs(jiffies);
  2290. seq_printf(s, " t_o/elap=%d/%d",
  2291. (new_interface ? hp->timeout :
  2292. jiffies_to_msecs(fp->timeout)),
  2293. (ms > hp->duration ? ms - hp->duration : 0));
  2294. }
  2295. seq_printf(s, "ms sgat=%d op=0x%02x\n", usg,
  2296. (int) srp->data.cmd_opcode);
  2297. }
  2298. if (list_empty(&fp->rq_list))
  2299. seq_puts(s, " No requests active\n");
  2300. read_unlock(&fp->rq_list_lock);
  2301. }
  2302. }
  2303. static int sg_proc_seq_show_debug(struct seq_file *s, void *v)
  2304. {
  2305. struct sg_proc_deviter * it = (struct sg_proc_deviter *) v;
  2306. Sg_device *sdp;
  2307. unsigned long iflags;
  2308. if (it && (0 == it->index))
  2309. seq_printf(s, "max_active_device=%d def_reserved_size=%d\n",
  2310. (int)it->max, sg_big_buff);
  2311. read_lock_irqsave(&sg_index_lock, iflags);
  2312. sdp = it ? sg_lookup_dev(it->index) : NULL;
  2313. if (NULL == sdp)
  2314. goto skip;
  2315. read_lock(&sdp->sfd_lock);
  2316. if (!list_empty(&sdp->sfds)) {
  2317. seq_printf(s, " >>> device=%s ", sdp->disk->disk_name);
  2318. if (atomic_read(&sdp->detaching))
  2319. seq_puts(s, "detaching pending close ");
  2320. else if (sdp->device) {
  2321. struct scsi_device *scsidp = sdp->device;
  2322. seq_printf(s, "%d:%d:%d:%llu em=%d",
  2323. scsidp->host->host_no,
  2324. scsidp->channel, scsidp->id,
  2325. scsidp->lun,
  2326. scsidp->host->hostt->emulated);
  2327. }
  2328. seq_printf(s, " sg_tablesize=%d excl=%d open_cnt=%d\n",
  2329. sdp->sg_tablesize, sdp->exclude, sdp->open_cnt);
  2330. sg_proc_debug_helper(s, sdp);
  2331. }
  2332. read_unlock(&sdp->sfd_lock);
  2333. skip:
  2334. read_unlock_irqrestore(&sg_index_lock, iflags);
  2335. return 0;
  2336. }
  2337. #endif /* CONFIG_SCSI_PROC_FS */
  2338. module_init(init_sg);
  2339. module_exit(exit_sg);