pktcdvd.c 76 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092
  1. /*
  2. * Copyright (C) 2000 Jens Axboe <axboe@suse.de>
  3. * Copyright (C) 2001-2004 Peter Osterlund <petero2@telia.com>
  4. * Copyright (C) 2006 Thomas Maier <balagi@justmail.de>
  5. *
  6. * May be copied or modified under the terms of the GNU General Public
  7. * License. See linux/COPYING for more information.
  8. *
  9. * Packet writing layer for ATAPI and SCSI CD-RW, DVD+RW, DVD-RW and
  10. * DVD-RAM devices.
  11. *
  12. * Theory of operation:
  13. *
  14. * At the lowest level, there is the standard driver for the CD/DVD device,
  15. * typically ide-cd.c or sr.c. This driver can handle read and write requests,
  16. * but it doesn't know anything about the special restrictions that apply to
  17. * packet writing. One restriction is that write requests must be aligned to
  18. * packet boundaries on the physical media, and the size of a write request
  19. * must be equal to the packet size. Another restriction is that a
  20. * GPCMD_FLUSH_CACHE command has to be issued to the drive before a read
  21. * command, if the previous command was a write.
  22. *
  23. * The purpose of the packet writing driver is to hide these restrictions from
  24. * higher layers, such as file systems, and present a block device that can be
  25. * randomly read and written using 2kB-sized blocks.
  26. *
  27. * The lowest layer in the packet writing driver is the packet I/O scheduler.
  28. * Its data is defined by the struct packet_iosched and includes two bio
  29. * queues with pending read and write requests. These queues are processed
  30. * by the pkt_iosched_process_queue() function. The write requests in this
  31. * queue are already properly aligned and sized. This layer is responsible for
  32. * issuing the flush cache commands and scheduling the I/O in a good order.
  33. *
  34. * The next layer transforms unaligned write requests to aligned writes. This
  35. * transformation requires reading missing pieces of data from the underlying
  36. * block device, assembling the pieces to full packets and queuing them to the
  37. * packet I/O scheduler.
  38. *
  39. * At the top layer there is a custom make_request_fn function that forwards
  40. * read requests directly to the iosched queue and puts write requests in the
  41. * unaligned write queue. A kernel thread performs the necessary read
  42. * gathering to convert the unaligned writes to aligned writes and then feeds
  43. * them to the packet I/O scheduler.
  44. *
  45. *************************************************************************/
  46. #include <linux/pktcdvd.h>
  47. #include <linux/module.h>
  48. #include <linux/types.h>
  49. #include <linux/kernel.h>
  50. #include <linux/kthread.h>
  51. #include <linux/errno.h>
  52. #include <linux/spinlock.h>
  53. #include <linux/file.h>
  54. #include <linux/proc_fs.h>
  55. #include <linux/seq_file.h>
  56. #include <linux/miscdevice.h>
  57. #include <linux/freezer.h>
  58. #include <linux/mutex.h>
  59. #include <scsi/scsi_cmnd.h>
  60. #include <scsi/scsi_ioctl.h>
  61. #include <scsi/scsi.h>
  62. #include <linux/debugfs.h>
  63. #include <linux/device.h>
  64. #include <asm/uaccess.h>
  65. #define DRIVER_NAME "pktcdvd"
  66. #if PACKET_DEBUG
  67. #define DPRINTK(fmt, args...) printk(KERN_NOTICE fmt, ##args)
  68. #else
  69. #define DPRINTK(fmt, args...)
  70. #endif
  71. #if PACKET_DEBUG > 1
  72. #define VPRINTK(fmt, args...) printk(KERN_NOTICE fmt, ##args)
  73. #else
  74. #define VPRINTK(fmt, args...)
  75. #endif
  76. #define MAX_SPEED 0xffff
  77. #define ZONE(sector, pd) (((sector) + (pd)->offset) & ~((pd)->settings.size - 1))
  78. static struct pktcdvd_device *pkt_devs[MAX_WRITERS];
  79. static struct proc_dir_entry *pkt_proc;
  80. static int pktdev_major;
  81. static int write_congestion_on = PKT_WRITE_CONGESTION_ON;
  82. static int write_congestion_off = PKT_WRITE_CONGESTION_OFF;
  83. static struct mutex ctl_mutex; /* Serialize open/close/setup/teardown */
  84. static mempool_t *psd_pool;
  85. static struct class *class_pktcdvd = NULL; /* /sys/class/pktcdvd */
  86. static struct dentry *pkt_debugfs_root = NULL; /* /sys/kernel/debug/pktcdvd */
  87. /* forward declaration */
  88. static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev);
  89. static int pkt_remove_dev(dev_t pkt_dev);
  90. static int pkt_seq_show(struct seq_file *m, void *p);
  91. /*
  92. * create and register a pktcdvd kernel object.
  93. */
  94. static struct pktcdvd_kobj* pkt_kobj_create(struct pktcdvd_device *pd,
  95. const char* name,
  96. struct kobject* parent,
  97. struct kobj_type* ktype)
  98. {
  99. struct pktcdvd_kobj *p;
  100. int error;
  101. p = kzalloc(sizeof(*p), GFP_KERNEL);
  102. if (!p)
  103. return NULL;
  104. p->pd = pd;
  105. error = kobject_init_and_add(&p->kobj, ktype, parent, "%s", name);
  106. if (error) {
  107. kobject_put(&p->kobj);
  108. return NULL;
  109. }
  110. kobject_uevent(&p->kobj, KOBJ_ADD);
  111. return p;
  112. }
  113. /*
  114. * remove a pktcdvd kernel object.
  115. */
  116. static void pkt_kobj_remove(struct pktcdvd_kobj *p)
  117. {
  118. if (p)
  119. kobject_put(&p->kobj);
  120. }
  121. /*
  122. * default release function for pktcdvd kernel objects.
  123. */
  124. static void pkt_kobj_release(struct kobject *kobj)
  125. {
  126. kfree(to_pktcdvdkobj(kobj));
  127. }
  128. /**********************************************************
  129. *
  130. * sysfs interface for pktcdvd
  131. * by (C) 2006 Thomas Maier <balagi@justmail.de>
  132. *
  133. **********************************************************/
  134. #define DEF_ATTR(_obj,_name,_mode) \
  135. static struct attribute _obj = { .name = _name, .mode = _mode }
  136. /**********************************************************
  137. /sys/class/pktcdvd/pktcdvd[0-7]/
  138. stat/reset
  139. stat/packets_started
  140. stat/packets_finished
  141. stat/kb_written
  142. stat/kb_read
  143. stat/kb_read_gather
  144. write_queue/size
  145. write_queue/congestion_off
  146. write_queue/congestion_on
  147. **********************************************************/
  148. DEF_ATTR(kobj_pkt_attr_st1, "reset", 0200);
  149. DEF_ATTR(kobj_pkt_attr_st2, "packets_started", 0444);
  150. DEF_ATTR(kobj_pkt_attr_st3, "packets_finished", 0444);
  151. DEF_ATTR(kobj_pkt_attr_st4, "kb_written", 0444);
  152. DEF_ATTR(kobj_pkt_attr_st5, "kb_read", 0444);
  153. DEF_ATTR(kobj_pkt_attr_st6, "kb_read_gather", 0444);
  154. static struct attribute *kobj_pkt_attrs_stat[] = {
  155. &kobj_pkt_attr_st1,
  156. &kobj_pkt_attr_st2,
  157. &kobj_pkt_attr_st3,
  158. &kobj_pkt_attr_st4,
  159. &kobj_pkt_attr_st5,
  160. &kobj_pkt_attr_st6,
  161. NULL
  162. };
  163. DEF_ATTR(kobj_pkt_attr_wq1, "size", 0444);
  164. DEF_ATTR(kobj_pkt_attr_wq2, "congestion_off", 0644);
  165. DEF_ATTR(kobj_pkt_attr_wq3, "congestion_on", 0644);
  166. static struct attribute *kobj_pkt_attrs_wqueue[] = {
  167. &kobj_pkt_attr_wq1,
  168. &kobj_pkt_attr_wq2,
  169. &kobj_pkt_attr_wq3,
  170. NULL
  171. };
  172. static ssize_t kobj_pkt_show(struct kobject *kobj,
  173. struct attribute *attr, char *data)
  174. {
  175. struct pktcdvd_device *pd = to_pktcdvdkobj(kobj)->pd;
  176. int n = 0;
  177. int v;
  178. if (strcmp(attr->name, "packets_started") == 0) {
  179. n = sprintf(data, "%lu\n", pd->stats.pkt_started);
  180. } else if (strcmp(attr->name, "packets_finished") == 0) {
  181. n = sprintf(data, "%lu\n", pd->stats.pkt_ended);
  182. } else if (strcmp(attr->name, "kb_written") == 0) {
  183. n = sprintf(data, "%lu\n", pd->stats.secs_w >> 1);
  184. } else if (strcmp(attr->name, "kb_read") == 0) {
  185. n = sprintf(data, "%lu\n", pd->stats.secs_r >> 1);
  186. } else if (strcmp(attr->name, "kb_read_gather") == 0) {
  187. n = sprintf(data, "%lu\n", pd->stats.secs_rg >> 1);
  188. } else if (strcmp(attr->name, "size") == 0) {
  189. spin_lock(&pd->lock);
  190. v = pd->bio_queue_size;
  191. spin_unlock(&pd->lock);
  192. n = sprintf(data, "%d\n", v);
  193. } else if (strcmp(attr->name, "congestion_off") == 0) {
  194. spin_lock(&pd->lock);
  195. v = pd->write_congestion_off;
  196. spin_unlock(&pd->lock);
  197. n = sprintf(data, "%d\n", v);
  198. } else if (strcmp(attr->name, "congestion_on") == 0) {
  199. spin_lock(&pd->lock);
  200. v = pd->write_congestion_on;
  201. spin_unlock(&pd->lock);
  202. n = sprintf(data, "%d\n", v);
  203. }
  204. return n;
  205. }
  206. static void init_write_congestion_marks(int* lo, int* hi)
  207. {
  208. if (*hi > 0) {
  209. *hi = max(*hi, 500);
  210. *hi = min(*hi, 1000000);
  211. if (*lo <= 0)
  212. *lo = *hi - 100;
  213. else {
  214. *lo = min(*lo, *hi - 100);
  215. *lo = max(*lo, 100);
  216. }
  217. } else {
  218. *hi = -1;
  219. *lo = -1;
  220. }
  221. }
  222. static ssize_t kobj_pkt_store(struct kobject *kobj,
  223. struct attribute *attr,
  224. const char *data, size_t len)
  225. {
  226. struct pktcdvd_device *pd = to_pktcdvdkobj(kobj)->pd;
  227. int val;
  228. if (strcmp(attr->name, "reset") == 0 && len > 0) {
  229. pd->stats.pkt_started = 0;
  230. pd->stats.pkt_ended = 0;
  231. pd->stats.secs_w = 0;
  232. pd->stats.secs_rg = 0;
  233. pd->stats.secs_r = 0;
  234. } else if (strcmp(attr->name, "congestion_off") == 0
  235. && sscanf(data, "%d", &val) == 1) {
  236. spin_lock(&pd->lock);
  237. pd->write_congestion_off = val;
  238. init_write_congestion_marks(&pd->write_congestion_off,
  239. &pd->write_congestion_on);
  240. spin_unlock(&pd->lock);
  241. } else if (strcmp(attr->name, "congestion_on") == 0
  242. && sscanf(data, "%d", &val) == 1) {
  243. spin_lock(&pd->lock);
  244. pd->write_congestion_on = val;
  245. init_write_congestion_marks(&pd->write_congestion_off,
  246. &pd->write_congestion_on);
  247. spin_unlock(&pd->lock);
  248. }
  249. return len;
  250. }
  251. static struct sysfs_ops kobj_pkt_ops = {
  252. .show = kobj_pkt_show,
  253. .store = kobj_pkt_store
  254. };
  255. static struct kobj_type kobj_pkt_type_stat = {
  256. .release = pkt_kobj_release,
  257. .sysfs_ops = &kobj_pkt_ops,
  258. .default_attrs = kobj_pkt_attrs_stat
  259. };
  260. static struct kobj_type kobj_pkt_type_wqueue = {
  261. .release = pkt_kobj_release,
  262. .sysfs_ops = &kobj_pkt_ops,
  263. .default_attrs = kobj_pkt_attrs_wqueue
  264. };
  265. static void pkt_sysfs_dev_new(struct pktcdvd_device *pd)
  266. {
  267. if (class_pktcdvd) {
  268. pd->dev = device_create(class_pktcdvd, NULL, MKDEV(0, 0), NULL,
  269. "%s", pd->name);
  270. if (IS_ERR(pd->dev))
  271. pd->dev = NULL;
  272. }
  273. if (pd->dev) {
  274. pd->kobj_stat = pkt_kobj_create(pd, "stat",
  275. &pd->dev->kobj,
  276. &kobj_pkt_type_stat);
  277. pd->kobj_wqueue = pkt_kobj_create(pd, "write_queue",
  278. &pd->dev->kobj,
  279. &kobj_pkt_type_wqueue);
  280. }
  281. }
  282. static void pkt_sysfs_dev_remove(struct pktcdvd_device *pd)
  283. {
  284. pkt_kobj_remove(pd->kobj_stat);
  285. pkt_kobj_remove(pd->kobj_wqueue);
  286. if (class_pktcdvd)
  287. device_unregister(pd->dev);
  288. }
  289. /********************************************************************
  290. /sys/class/pktcdvd/
  291. add map block device
  292. remove unmap packet dev
  293. device_map show mappings
  294. *******************************************************************/
  295. static void class_pktcdvd_release(struct class *cls)
  296. {
  297. kfree(cls);
  298. }
  299. static ssize_t class_pktcdvd_show_map(struct class *c, char *data)
  300. {
  301. int n = 0;
  302. int idx;
  303. mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
  304. for (idx = 0; idx < MAX_WRITERS; idx++) {
  305. struct pktcdvd_device *pd = pkt_devs[idx];
  306. if (!pd)
  307. continue;
  308. n += sprintf(data+n, "%s %u:%u %u:%u\n",
  309. pd->name,
  310. MAJOR(pd->pkt_dev), MINOR(pd->pkt_dev),
  311. MAJOR(pd->bdev->bd_dev),
  312. MINOR(pd->bdev->bd_dev));
  313. }
  314. mutex_unlock(&ctl_mutex);
  315. return n;
  316. }
  317. static ssize_t class_pktcdvd_store_add(struct class *c, const char *buf,
  318. size_t count)
  319. {
  320. unsigned int major, minor;
  321. if (sscanf(buf, "%u:%u", &major, &minor) == 2) {
  322. /* pkt_setup_dev() expects caller to hold reference to self */
  323. if (!try_module_get(THIS_MODULE))
  324. return -ENODEV;
  325. pkt_setup_dev(MKDEV(major, minor), NULL);
  326. module_put(THIS_MODULE);
  327. return count;
  328. }
  329. return -EINVAL;
  330. }
  331. static ssize_t class_pktcdvd_store_remove(struct class *c, const char *buf,
  332. size_t count)
  333. {
  334. unsigned int major, minor;
  335. if (sscanf(buf, "%u:%u", &major, &minor) == 2) {
  336. pkt_remove_dev(MKDEV(major, minor));
  337. return count;
  338. }
  339. return -EINVAL;
  340. }
  341. static struct class_attribute class_pktcdvd_attrs[] = {
  342. __ATTR(add, 0200, NULL, class_pktcdvd_store_add),
  343. __ATTR(remove, 0200, NULL, class_pktcdvd_store_remove),
  344. __ATTR(device_map, 0444, class_pktcdvd_show_map, NULL),
  345. __ATTR_NULL
  346. };
  347. static int pkt_sysfs_init(void)
  348. {
  349. int ret = 0;
  350. /*
  351. * create control files in sysfs
  352. * /sys/class/pktcdvd/...
  353. */
  354. class_pktcdvd = kzalloc(sizeof(*class_pktcdvd), GFP_KERNEL);
  355. if (!class_pktcdvd)
  356. return -ENOMEM;
  357. class_pktcdvd->name = DRIVER_NAME;
  358. class_pktcdvd->owner = THIS_MODULE;
  359. class_pktcdvd->class_release = class_pktcdvd_release;
  360. class_pktcdvd->class_attrs = class_pktcdvd_attrs;
  361. ret = class_register(class_pktcdvd);
  362. if (ret) {
  363. kfree(class_pktcdvd);
  364. class_pktcdvd = NULL;
  365. printk(DRIVER_NAME": failed to create class pktcdvd\n");
  366. return ret;
  367. }
  368. return 0;
  369. }
  370. static void pkt_sysfs_cleanup(void)
  371. {
  372. if (class_pktcdvd)
  373. class_destroy(class_pktcdvd);
  374. class_pktcdvd = NULL;
  375. }
  376. /********************************************************************
  377. entries in debugfs
  378. /sys/kernel/debug/pktcdvd[0-7]/
  379. info
  380. *******************************************************************/
  381. static int pkt_debugfs_seq_show(struct seq_file *m, void *p)
  382. {
  383. return pkt_seq_show(m, p);
  384. }
  385. static int pkt_debugfs_fops_open(struct inode *inode, struct file *file)
  386. {
  387. return single_open(file, pkt_debugfs_seq_show, inode->i_private);
  388. }
  389. static const struct file_operations debug_fops = {
  390. .open = pkt_debugfs_fops_open,
  391. .read = seq_read,
  392. .llseek = seq_lseek,
  393. .release = single_release,
  394. .owner = THIS_MODULE,
  395. };
  396. static void pkt_debugfs_dev_new(struct pktcdvd_device *pd)
  397. {
  398. if (!pkt_debugfs_root)
  399. return;
  400. pd->dfs_f_info = NULL;
  401. pd->dfs_d_root = debugfs_create_dir(pd->name, pkt_debugfs_root);
  402. if (IS_ERR(pd->dfs_d_root)) {
  403. pd->dfs_d_root = NULL;
  404. return;
  405. }
  406. pd->dfs_f_info = debugfs_create_file("info", S_IRUGO,
  407. pd->dfs_d_root, pd, &debug_fops);
  408. if (IS_ERR(pd->dfs_f_info)) {
  409. pd->dfs_f_info = NULL;
  410. return;
  411. }
  412. }
  413. static void pkt_debugfs_dev_remove(struct pktcdvd_device *pd)
  414. {
  415. if (!pkt_debugfs_root)
  416. return;
  417. if (pd->dfs_f_info)
  418. debugfs_remove(pd->dfs_f_info);
  419. pd->dfs_f_info = NULL;
  420. if (pd->dfs_d_root)
  421. debugfs_remove(pd->dfs_d_root);
  422. pd->dfs_d_root = NULL;
  423. }
  424. static void pkt_debugfs_init(void)
  425. {
  426. pkt_debugfs_root = debugfs_create_dir(DRIVER_NAME, NULL);
  427. if (IS_ERR(pkt_debugfs_root)) {
  428. pkt_debugfs_root = NULL;
  429. return;
  430. }
  431. }
  432. static void pkt_debugfs_cleanup(void)
  433. {
  434. if (!pkt_debugfs_root)
  435. return;
  436. debugfs_remove(pkt_debugfs_root);
  437. pkt_debugfs_root = NULL;
  438. }
  439. /* ----------------------------------------------------------*/
  440. static void pkt_bio_finished(struct pktcdvd_device *pd)
  441. {
  442. BUG_ON(atomic_read(&pd->cdrw.pending_bios) <= 0);
  443. if (atomic_dec_and_test(&pd->cdrw.pending_bios)) {
  444. VPRINTK(DRIVER_NAME": queue empty\n");
  445. atomic_set(&pd->iosched.attention, 1);
  446. wake_up(&pd->wqueue);
  447. }
  448. }
  449. static void pkt_bio_destructor(struct bio *bio)
  450. {
  451. kfree(bio->bi_io_vec);
  452. kfree(bio);
  453. }
  454. static struct bio *pkt_bio_alloc(int nr_iovecs)
  455. {
  456. struct bio_vec *bvl = NULL;
  457. struct bio *bio;
  458. bio = kmalloc(sizeof(struct bio), GFP_KERNEL);
  459. if (!bio)
  460. goto no_bio;
  461. bio_init(bio);
  462. bvl = kcalloc(nr_iovecs, sizeof(struct bio_vec), GFP_KERNEL);
  463. if (!bvl)
  464. goto no_bvl;
  465. bio->bi_max_vecs = nr_iovecs;
  466. bio->bi_io_vec = bvl;
  467. bio->bi_destructor = pkt_bio_destructor;
  468. return bio;
  469. no_bvl:
  470. kfree(bio);
  471. no_bio:
  472. return NULL;
  473. }
  474. /*
  475. * Allocate a packet_data struct
  476. */
  477. static struct packet_data *pkt_alloc_packet_data(int frames)
  478. {
  479. int i;
  480. struct packet_data *pkt;
  481. pkt = kzalloc(sizeof(struct packet_data), GFP_KERNEL);
  482. if (!pkt)
  483. goto no_pkt;
  484. pkt->frames = frames;
  485. pkt->w_bio = pkt_bio_alloc(frames);
  486. if (!pkt->w_bio)
  487. goto no_bio;
  488. for (i = 0; i < frames / FRAMES_PER_PAGE; i++) {
  489. pkt->pages[i] = alloc_page(GFP_KERNEL|__GFP_ZERO);
  490. if (!pkt->pages[i])
  491. goto no_page;
  492. }
  493. spin_lock_init(&pkt->lock);
  494. bio_list_init(&pkt->orig_bios);
  495. for (i = 0; i < frames; i++) {
  496. struct bio *bio = pkt_bio_alloc(1);
  497. if (!bio)
  498. goto no_rd_bio;
  499. pkt->r_bios[i] = bio;
  500. }
  501. return pkt;
  502. no_rd_bio:
  503. for (i = 0; i < frames; i++) {
  504. struct bio *bio = pkt->r_bios[i];
  505. if (bio)
  506. bio_put(bio);
  507. }
  508. no_page:
  509. for (i = 0; i < frames / FRAMES_PER_PAGE; i++)
  510. if (pkt->pages[i])
  511. __free_page(pkt->pages[i]);
  512. bio_put(pkt->w_bio);
  513. no_bio:
  514. kfree(pkt);
  515. no_pkt:
  516. return NULL;
  517. }
  518. /*
  519. * Free a packet_data struct
  520. */
  521. static void pkt_free_packet_data(struct packet_data *pkt)
  522. {
  523. int i;
  524. for (i = 0; i < pkt->frames; i++) {
  525. struct bio *bio = pkt->r_bios[i];
  526. if (bio)
  527. bio_put(bio);
  528. }
  529. for (i = 0; i < pkt->frames / FRAMES_PER_PAGE; i++)
  530. __free_page(pkt->pages[i]);
  531. bio_put(pkt->w_bio);
  532. kfree(pkt);
  533. }
  534. static void pkt_shrink_pktlist(struct pktcdvd_device *pd)
  535. {
  536. struct packet_data *pkt, *next;
  537. BUG_ON(!list_empty(&pd->cdrw.pkt_active_list));
  538. list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_free_list, list) {
  539. pkt_free_packet_data(pkt);
  540. }
  541. INIT_LIST_HEAD(&pd->cdrw.pkt_free_list);
  542. }
  543. static int pkt_grow_pktlist(struct pktcdvd_device *pd, int nr_packets)
  544. {
  545. struct packet_data *pkt;
  546. BUG_ON(!list_empty(&pd->cdrw.pkt_free_list));
  547. while (nr_packets > 0) {
  548. pkt = pkt_alloc_packet_data(pd->settings.size >> 2);
  549. if (!pkt) {
  550. pkt_shrink_pktlist(pd);
  551. return 0;
  552. }
  553. pkt->id = nr_packets;
  554. pkt->pd = pd;
  555. list_add(&pkt->list, &pd->cdrw.pkt_free_list);
  556. nr_packets--;
  557. }
  558. return 1;
  559. }
  560. static inline struct pkt_rb_node *pkt_rbtree_next(struct pkt_rb_node *node)
  561. {
  562. struct rb_node *n = rb_next(&node->rb_node);
  563. if (!n)
  564. return NULL;
  565. return rb_entry(n, struct pkt_rb_node, rb_node);
  566. }
  567. static void pkt_rbtree_erase(struct pktcdvd_device *pd, struct pkt_rb_node *node)
  568. {
  569. rb_erase(&node->rb_node, &pd->bio_queue);
  570. mempool_free(node, pd->rb_pool);
  571. pd->bio_queue_size--;
  572. BUG_ON(pd->bio_queue_size < 0);
  573. }
  574. /*
  575. * Find the first node in the pd->bio_queue rb tree with a starting sector >= s.
  576. */
  577. static struct pkt_rb_node *pkt_rbtree_find(struct pktcdvd_device *pd, sector_t s)
  578. {
  579. struct rb_node *n = pd->bio_queue.rb_node;
  580. struct rb_node *next;
  581. struct pkt_rb_node *tmp;
  582. if (!n) {
  583. BUG_ON(pd->bio_queue_size > 0);
  584. return NULL;
  585. }
  586. for (;;) {
  587. tmp = rb_entry(n, struct pkt_rb_node, rb_node);
  588. if (s <= tmp->bio->bi_sector)
  589. next = n->rb_left;
  590. else
  591. next = n->rb_right;
  592. if (!next)
  593. break;
  594. n = next;
  595. }
  596. if (s > tmp->bio->bi_sector) {
  597. tmp = pkt_rbtree_next(tmp);
  598. if (!tmp)
  599. return NULL;
  600. }
  601. BUG_ON(s > tmp->bio->bi_sector);
  602. return tmp;
  603. }
  604. /*
  605. * Insert a node into the pd->bio_queue rb tree.
  606. */
  607. static void pkt_rbtree_insert(struct pktcdvd_device *pd, struct pkt_rb_node *node)
  608. {
  609. struct rb_node **p = &pd->bio_queue.rb_node;
  610. struct rb_node *parent = NULL;
  611. sector_t s = node->bio->bi_sector;
  612. struct pkt_rb_node *tmp;
  613. while (*p) {
  614. parent = *p;
  615. tmp = rb_entry(parent, struct pkt_rb_node, rb_node);
  616. if (s < tmp->bio->bi_sector)
  617. p = &(*p)->rb_left;
  618. else
  619. p = &(*p)->rb_right;
  620. }
  621. rb_link_node(&node->rb_node, parent, p);
  622. rb_insert_color(&node->rb_node, &pd->bio_queue);
  623. pd->bio_queue_size++;
  624. }
  625. /*
  626. * Send a packet_command to the underlying block device and
  627. * wait for completion.
  628. */
  629. static int pkt_generic_packet(struct pktcdvd_device *pd, struct packet_command *cgc)
  630. {
  631. struct request_queue *q = bdev_get_queue(pd->bdev);
  632. struct request *rq;
  633. int ret = 0;
  634. rq = blk_get_request(q, (cgc->data_direction == CGC_DATA_WRITE) ?
  635. WRITE : READ, __GFP_WAIT);
  636. if (cgc->buflen) {
  637. if (blk_rq_map_kern(q, rq, cgc->buffer, cgc->buflen, __GFP_WAIT))
  638. goto out;
  639. }
  640. rq->cmd_len = COMMAND_SIZE(cgc->cmd[0]);
  641. memcpy(rq->cmd, cgc->cmd, CDROM_PACKET_SIZE);
  642. rq->timeout = 60*HZ;
  643. rq->cmd_type = REQ_TYPE_BLOCK_PC;
  644. rq->cmd_flags |= REQ_HARDBARRIER;
  645. if (cgc->quiet)
  646. rq->cmd_flags |= REQ_QUIET;
  647. blk_execute_rq(rq->q, pd->bdev->bd_disk, rq, 0);
  648. if (rq->errors)
  649. ret = -EIO;
  650. out:
  651. blk_put_request(rq);
  652. return ret;
  653. }
  654. /*
  655. * A generic sense dump / resolve mechanism should be implemented across
  656. * all ATAPI + SCSI devices.
  657. */
  658. static void pkt_dump_sense(struct packet_command *cgc)
  659. {
  660. static char *info[9] = { "No sense", "Recovered error", "Not ready",
  661. "Medium error", "Hardware error", "Illegal request",
  662. "Unit attention", "Data protect", "Blank check" };
  663. int i;
  664. struct request_sense *sense = cgc->sense;
  665. printk(DRIVER_NAME":");
  666. for (i = 0; i < CDROM_PACKET_SIZE; i++)
  667. printk(" %02x", cgc->cmd[i]);
  668. printk(" - ");
  669. if (sense == NULL) {
  670. printk("no sense\n");
  671. return;
  672. }
  673. printk("sense %02x.%02x.%02x", sense->sense_key, sense->asc, sense->ascq);
  674. if (sense->sense_key > 8) {
  675. printk(" (INVALID)\n");
  676. return;
  677. }
  678. printk(" (%s)\n", info[sense->sense_key]);
  679. }
  680. /*
  681. * flush the drive cache to media
  682. */
  683. static int pkt_flush_cache(struct pktcdvd_device *pd)
  684. {
  685. struct packet_command cgc;
  686. init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
  687. cgc.cmd[0] = GPCMD_FLUSH_CACHE;
  688. cgc.quiet = 1;
  689. /*
  690. * the IMMED bit -- we default to not setting it, although that
  691. * would allow a much faster close, this is safer
  692. */
  693. #if 0
  694. cgc.cmd[1] = 1 << 1;
  695. #endif
  696. return pkt_generic_packet(pd, &cgc);
  697. }
  698. /*
  699. * speed is given as the normal factor, e.g. 4 for 4x
  700. */
  701. static noinline_for_stack int pkt_set_speed(struct pktcdvd_device *pd,
  702. unsigned write_speed, unsigned read_speed)
  703. {
  704. struct packet_command cgc;
  705. struct request_sense sense;
  706. int ret;
  707. init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
  708. cgc.sense = &sense;
  709. cgc.cmd[0] = GPCMD_SET_SPEED;
  710. cgc.cmd[2] = (read_speed >> 8) & 0xff;
  711. cgc.cmd[3] = read_speed & 0xff;
  712. cgc.cmd[4] = (write_speed >> 8) & 0xff;
  713. cgc.cmd[5] = write_speed & 0xff;
  714. if ((ret = pkt_generic_packet(pd, &cgc)))
  715. pkt_dump_sense(&cgc);
  716. return ret;
  717. }
  718. /*
  719. * Queue a bio for processing by the low-level CD device. Must be called
  720. * from process context.
  721. */
  722. static void pkt_queue_bio(struct pktcdvd_device *pd, struct bio *bio)
  723. {
  724. spin_lock(&pd->iosched.lock);
  725. if (bio_data_dir(bio) == READ)
  726. bio_list_add(&pd->iosched.read_queue, bio);
  727. else
  728. bio_list_add(&pd->iosched.write_queue, bio);
  729. spin_unlock(&pd->iosched.lock);
  730. atomic_set(&pd->iosched.attention, 1);
  731. wake_up(&pd->wqueue);
  732. }
  733. /*
  734. * Process the queued read/write requests. This function handles special
  735. * requirements for CDRW drives:
  736. * - A cache flush command must be inserted before a read request if the
  737. * previous request was a write.
  738. * - Switching between reading and writing is slow, so don't do it more often
  739. * than necessary.
  740. * - Optimize for throughput at the expense of latency. This means that streaming
  741. * writes will never be interrupted by a read, but if the drive has to seek
  742. * before the next write, switch to reading instead if there are any pending
  743. * read requests.
  744. * - Set the read speed according to current usage pattern. When only reading
  745. * from the device, it's best to use the highest possible read speed, but
  746. * when switching often between reading and writing, it's better to have the
  747. * same read and write speeds.
  748. */
  749. static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
  750. {
  751. if (atomic_read(&pd->iosched.attention) == 0)
  752. return;
  753. atomic_set(&pd->iosched.attention, 0);
  754. for (;;) {
  755. struct bio *bio;
  756. int reads_queued, writes_queued;
  757. spin_lock(&pd->iosched.lock);
  758. reads_queued = !bio_list_empty(&pd->iosched.read_queue);
  759. writes_queued = !bio_list_empty(&pd->iosched.write_queue);
  760. spin_unlock(&pd->iosched.lock);
  761. if (!reads_queued && !writes_queued)
  762. break;
  763. if (pd->iosched.writing) {
  764. int need_write_seek = 1;
  765. spin_lock(&pd->iosched.lock);
  766. bio = bio_list_peek(&pd->iosched.write_queue);
  767. spin_unlock(&pd->iosched.lock);
  768. if (bio && (bio->bi_sector == pd->iosched.last_write))
  769. need_write_seek = 0;
  770. if (need_write_seek && reads_queued) {
  771. if (atomic_read(&pd->cdrw.pending_bios) > 0) {
  772. VPRINTK(DRIVER_NAME": write, waiting\n");
  773. break;
  774. }
  775. pkt_flush_cache(pd);
  776. pd->iosched.writing = 0;
  777. }
  778. } else {
  779. if (!reads_queued && writes_queued) {
  780. if (atomic_read(&pd->cdrw.pending_bios) > 0) {
  781. VPRINTK(DRIVER_NAME": read, waiting\n");
  782. break;
  783. }
  784. pd->iosched.writing = 1;
  785. }
  786. }
  787. spin_lock(&pd->iosched.lock);
  788. if (pd->iosched.writing)
  789. bio = bio_list_pop(&pd->iosched.write_queue);
  790. else
  791. bio = bio_list_pop(&pd->iosched.read_queue);
  792. spin_unlock(&pd->iosched.lock);
  793. if (!bio)
  794. continue;
  795. if (bio_data_dir(bio) == READ)
  796. pd->iosched.successive_reads += bio->bi_size >> 10;
  797. else {
  798. pd->iosched.successive_reads = 0;
  799. pd->iosched.last_write = bio->bi_sector + bio_sectors(bio);
  800. }
  801. if (pd->iosched.successive_reads >= HI_SPEED_SWITCH) {
  802. if (pd->read_speed == pd->write_speed) {
  803. pd->read_speed = MAX_SPEED;
  804. pkt_set_speed(pd, pd->write_speed, pd->read_speed);
  805. }
  806. } else {
  807. if (pd->read_speed != pd->write_speed) {
  808. pd->read_speed = pd->write_speed;
  809. pkt_set_speed(pd, pd->write_speed, pd->read_speed);
  810. }
  811. }
  812. atomic_inc(&pd->cdrw.pending_bios);
  813. generic_make_request(bio);
  814. }
  815. }
  816. /*
  817. * Special care is needed if the underlying block device has a small
  818. * max_phys_segments value.
  819. */
  820. static int pkt_set_segment_merging(struct pktcdvd_device *pd, struct request_queue *q)
  821. {
  822. if ((pd->settings.size << 9) / CD_FRAMESIZE
  823. <= queue_max_phys_segments(q)) {
  824. /*
  825. * The cdrom device can handle one segment/frame
  826. */
  827. clear_bit(PACKET_MERGE_SEGS, &pd->flags);
  828. return 0;
  829. } else if ((pd->settings.size << 9) / PAGE_SIZE
  830. <= queue_max_phys_segments(q)) {
  831. /*
  832. * We can handle this case at the expense of some extra memory
  833. * copies during write operations
  834. */
  835. set_bit(PACKET_MERGE_SEGS, &pd->flags);
  836. return 0;
  837. } else {
  838. printk(DRIVER_NAME": cdrom max_phys_segments too small\n");
  839. return -EIO;
  840. }
  841. }
  842. /*
  843. * Copy CD_FRAMESIZE bytes from src_bio into a destination page
  844. */
  845. static void pkt_copy_bio_data(struct bio *src_bio, int seg, int offs, struct page *dst_page, int dst_offs)
  846. {
  847. unsigned int copy_size = CD_FRAMESIZE;
  848. while (copy_size > 0) {
  849. struct bio_vec *src_bvl = bio_iovec_idx(src_bio, seg);
  850. void *vfrom = kmap_atomic(src_bvl->bv_page, KM_USER0) +
  851. src_bvl->bv_offset + offs;
  852. void *vto = page_address(dst_page) + dst_offs;
  853. int len = min_t(int, copy_size, src_bvl->bv_len - offs);
  854. BUG_ON(len < 0);
  855. memcpy(vto, vfrom, len);
  856. kunmap_atomic(vfrom, KM_USER0);
  857. seg++;
  858. offs = 0;
  859. dst_offs += len;
  860. copy_size -= len;
  861. }
  862. }
  863. /*
  864. * Copy all data for this packet to pkt->pages[], so that
  865. * a) The number of required segments for the write bio is minimized, which
  866. * is necessary for some scsi controllers.
  867. * b) The data can be used as cache to avoid read requests if we receive a
  868. * new write request for the same zone.
  869. */
  870. static void pkt_make_local_copy(struct packet_data *pkt, struct bio_vec *bvec)
  871. {
  872. int f, p, offs;
  873. /* Copy all data to pkt->pages[] */
  874. p = 0;
  875. offs = 0;
  876. for (f = 0; f < pkt->frames; f++) {
  877. if (bvec[f].bv_page != pkt->pages[p]) {
  878. void *vfrom = kmap_atomic(bvec[f].bv_page, KM_USER0) + bvec[f].bv_offset;
  879. void *vto = page_address(pkt->pages[p]) + offs;
  880. memcpy(vto, vfrom, CD_FRAMESIZE);
  881. kunmap_atomic(vfrom, KM_USER0);
  882. bvec[f].bv_page = pkt->pages[p];
  883. bvec[f].bv_offset = offs;
  884. } else {
  885. BUG_ON(bvec[f].bv_offset != offs);
  886. }
  887. offs += CD_FRAMESIZE;
  888. if (offs >= PAGE_SIZE) {
  889. offs = 0;
  890. p++;
  891. }
  892. }
  893. }
  894. static void pkt_end_io_read(struct bio *bio, int err)
  895. {
  896. struct packet_data *pkt = bio->bi_private;
  897. struct pktcdvd_device *pd = pkt->pd;
  898. BUG_ON(!pd);
  899. VPRINTK("pkt_end_io_read: bio=%p sec0=%llx sec=%llx err=%d\n", bio,
  900. (unsigned long long)pkt->sector, (unsigned long long)bio->bi_sector, err);
  901. if (err)
  902. atomic_inc(&pkt->io_errors);
  903. if (atomic_dec_and_test(&pkt->io_wait)) {
  904. atomic_inc(&pkt->run_sm);
  905. wake_up(&pd->wqueue);
  906. }
  907. pkt_bio_finished(pd);
  908. }
  909. static void pkt_end_io_packet_write(struct bio *bio, int err)
  910. {
  911. struct packet_data *pkt = bio->bi_private;
  912. struct pktcdvd_device *pd = pkt->pd;
  913. BUG_ON(!pd);
  914. VPRINTK("pkt_end_io_packet_write: id=%d, err=%d\n", pkt->id, err);
  915. pd->stats.pkt_ended++;
  916. pkt_bio_finished(pd);
  917. atomic_dec(&pkt->io_wait);
  918. atomic_inc(&pkt->run_sm);
  919. wake_up(&pd->wqueue);
  920. }
  921. /*
  922. * Schedule reads for the holes in a packet
  923. */
  924. static void pkt_gather_data(struct pktcdvd_device *pd, struct packet_data *pkt)
  925. {
  926. int frames_read = 0;
  927. struct bio *bio;
  928. int f;
  929. char written[PACKET_MAX_SIZE];
  930. BUG_ON(bio_list_empty(&pkt->orig_bios));
  931. atomic_set(&pkt->io_wait, 0);
  932. atomic_set(&pkt->io_errors, 0);
  933. /*
  934. * Figure out which frames we need to read before we can write.
  935. */
  936. memset(written, 0, sizeof(written));
  937. spin_lock(&pkt->lock);
  938. bio_list_for_each(bio, &pkt->orig_bios) {
  939. int first_frame = (bio->bi_sector - pkt->sector) / (CD_FRAMESIZE >> 9);
  940. int num_frames = bio->bi_size / CD_FRAMESIZE;
  941. pd->stats.secs_w += num_frames * (CD_FRAMESIZE >> 9);
  942. BUG_ON(first_frame < 0);
  943. BUG_ON(first_frame + num_frames > pkt->frames);
  944. for (f = first_frame; f < first_frame + num_frames; f++)
  945. written[f] = 1;
  946. }
  947. spin_unlock(&pkt->lock);
  948. if (pkt->cache_valid) {
  949. VPRINTK("pkt_gather_data: zone %llx cached\n",
  950. (unsigned long long)pkt->sector);
  951. goto out_account;
  952. }
  953. /*
  954. * Schedule reads for missing parts of the packet.
  955. */
  956. for (f = 0; f < pkt->frames; f++) {
  957. struct bio_vec *vec;
  958. int p, offset;
  959. if (written[f])
  960. continue;
  961. bio = pkt->r_bios[f];
  962. vec = bio->bi_io_vec;
  963. bio_init(bio);
  964. bio->bi_max_vecs = 1;
  965. bio->bi_sector = pkt->sector + f * (CD_FRAMESIZE >> 9);
  966. bio->bi_bdev = pd->bdev;
  967. bio->bi_end_io = pkt_end_io_read;
  968. bio->bi_private = pkt;
  969. bio->bi_io_vec = vec;
  970. bio->bi_destructor = pkt_bio_destructor;
  971. p = (f * CD_FRAMESIZE) / PAGE_SIZE;
  972. offset = (f * CD_FRAMESIZE) % PAGE_SIZE;
  973. VPRINTK("pkt_gather_data: Adding frame %d, page:%p offs:%d\n",
  974. f, pkt->pages[p], offset);
  975. if (!bio_add_page(bio, pkt->pages[p], CD_FRAMESIZE, offset))
  976. BUG();
  977. atomic_inc(&pkt->io_wait);
  978. bio->bi_rw = READ;
  979. pkt_queue_bio(pd, bio);
  980. frames_read++;
  981. }
  982. out_account:
  983. VPRINTK("pkt_gather_data: need %d frames for zone %llx\n",
  984. frames_read, (unsigned long long)pkt->sector);
  985. pd->stats.pkt_started++;
  986. pd->stats.secs_rg += frames_read * (CD_FRAMESIZE >> 9);
  987. }
  988. /*
  989. * Find a packet matching zone, or the least recently used packet if
  990. * there is no match.
  991. */
  992. static struct packet_data *pkt_get_packet_data(struct pktcdvd_device *pd, int zone)
  993. {
  994. struct packet_data *pkt;
  995. list_for_each_entry(pkt, &pd->cdrw.pkt_free_list, list) {
  996. if (pkt->sector == zone || pkt->list.next == &pd->cdrw.pkt_free_list) {
  997. list_del_init(&pkt->list);
  998. if (pkt->sector != zone)
  999. pkt->cache_valid = 0;
  1000. return pkt;
  1001. }
  1002. }
  1003. BUG();
  1004. return NULL;
  1005. }
  1006. static void pkt_put_packet_data(struct pktcdvd_device *pd, struct packet_data *pkt)
  1007. {
  1008. if (pkt->cache_valid) {
  1009. list_add(&pkt->list, &pd->cdrw.pkt_free_list);
  1010. } else {
  1011. list_add_tail(&pkt->list, &pd->cdrw.pkt_free_list);
  1012. }
  1013. }
  1014. /*
  1015. * recover a failed write, query for relocation if possible
  1016. *
  1017. * returns 1 if recovery is possible, or 0 if not
  1018. *
  1019. */
  1020. static int pkt_start_recovery(struct packet_data *pkt)
  1021. {
  1022. /*
  1023. * FIXME. We need help from the file system to implement
  1024. * recovery handling.
  1025. */
  1026. return 0;
  1027. #if 0
  1028. struct request *rq = pkt->rq;
  1029. struct pktcdvd_device *pd = rq->rq_disk->private_data;
  1030. struct block_device *pkt_bdev;
  1031. struct super_block *sb = NULL;
  1032. unsigned long old_block, new_block;
  1033. sector_t new_sector;
  1034. pkt_bdev = bdget(kdev_t_to_nr(pd->pkt_dev));
  1035. if (pkt_bdev) {
  1036. sb = get_super(pkt_bdev);
  1037. bdput(pkt_bdev);
  1038. }
  1039. if (!sb)
  1040. return 0;
  1041. if (!sb->s_op || !sb->s_op->relocate_blocks)
  1042. goto out;
  1043. old_block = pkt->sector / (CD_FRAMESIZE >> 9);
  1044. if (sb->s_op->relocate_blocks(sb, old_block, &new_block))
  1045. goto out;
  1046. new_sector = new_block * (CD_FRAMESIZE >> 9);
  1047. pkt->sector = new_sector;
  1048. pkt->bio->bi_sector = new_sector;
  1049. pkt->bio->bi_next = NULL;
  1050. pkt->bio->bi_flags = 1 << BIO_UPTODATE;
  1051. pkt->bio->bi_idx = 0;
  1052. BUG_ON(pkt->bio->bi_rw != (1 << BIO_RW));
  1053. BUG_ON(pkt->bio->bi_vcnt != pkt->frames);
  1054. BUG_ON(pkt->bio->bi_size != pkt->frames * CD_FRAMESIZE);
  1055. BUG_ON(pkt->bio->bi_end_io != pkt_end_io_packet_write);
  1056. BUG_ON(pkt->bio->bi_private != pkt);
  1057. drop_super(sb);
  1058. return 1;
  1059. out:
  1060. drop_super(sb);
  1061. return 0;
  1062. #endif
  1063. }
  1064. static inline void pkt_set_state(struct packet_data *pkt, enum packet_data_state state)
  1065. {
  1066. #if PACKET_DEBUG > 1
  1067. static const char *state_name[] = {
  1068. "IDLE", "WAITING", "READ_WAIT", "WRITE_WAIT", "RECOVERY", "FINISHED"
  1069. };
  1070. enum packet_data_state old_state = pkt->state;
  1071. VPRINTK("pkt %2d : s=%6llx %s -> %s\n", pkt->id, (unsigned long long)pkt->sector,
  1072. state_name[old_state], state_name[state]);
  1073. #endif
  1074. pkt->state = state;
  1075. }
  1076. /*
  1077. * Scan the work queue to see if we can start a new packet.
  1078. * returns non-zero if any work was done.
  1079. */
  1080. static int pkt_handle_queue(struct pktcdvd_device *pd)
  1081. {
  1082. struct packet_data *pkt, *p;
  1083. struct bio *bio = NULL;
  1084. sector_t zone = 0; /* Suppress gcc warning */
  1085. struct pkt_rb_node *node, *first_node;
  1086. struct rb_node *n;
  1087. int wakeup;
  1088. VPRINTK("handle_queue\n");
  1089. atomic_set(&pd->scan_queue, 0);
  1090. if (list_empty(&pd->cdrw.pkt_free_list)) {
  1091. VPRINTK("handle_queue: no pkt\n");
  1092. return 0;
  1093. }
  1094. /*
  1095. * Try to find a zone we are not already working on.
  1096. */
  1097. spin_lock(&pd->lock);
  1098. first_node = pkt_rbtree_find(pd, pd->current_sector);
  1099. if (!first_node) {
  1100. n = rb_first(&pd->bio_queue);
  1101. if (n)
  1102. first_node = rb_entry(n, struct pkt_rb_node, rb_node);
  1103. }
  1104. node = first_node;
  1105. while (node) {
  1106. bio = node->bio;
  1107. zone = ZONE(bio->bi_sector, pd);
  1108. list_for_each_entry(p, &pd->cdrw.pkt_active_list, list) {
  1109. if (p->sector == zone) {
  1110. bio = NULL;
  1111. goto try_next_bio;
  1112. }
  1113. }
  1114. break;
  1115. try_next_bio:
  1116. node = pkt_rbtree_next(node);
  1117. if (!node) {
  1118. n = rb_first(&pd->bio_queue);
  1119. if (n)
  1120. node = rb_entry(n, struct pkt_rb_node, rb_node);
  1121. }
  1122. if (node == first_node)
  1123. node = NULL;
  1124. }
  1125. spin_unlock(&pd->lock);
  1126. if (!bio) {
  1127. VPRINTK("handle_queue: no bio\n");
  1128. return 0;
  1129. }
  1130. pkt = pkt_get_packet_data(pd, zone);
  1131. pd->current_sector = zone + pd->settings.size;
  1132. pkt->sector = zone;
  1133. BUG_ON(pkt->frames != pd->settings.size >> 2);
  1134. pkt->write_size = 0;
  1135. /*
  1136. * Scan work queue for bios in the same zone and link them
  1137. * to this packet.
  1138. */
  1139. spin_lock(&pd->lock);
  1140. VPRINTK("pkt_handle_queue: looking for zone %llx\n", (unsigned long long)zone);
  1141. while ((node = pkt_rbtree_find(pd, zone)) != NULL) {
  1142. bio = node->bio;
  1143. VPRINTK("pkt_handle_queue: found zone=%llx\n",
  1144. (unsigned long long)ZONE(bio->bi_sector, pd));
  1145. if (ZONE(bio->bi_sector, pd) != zone)
  1146. break;
  1147. pkt_rbtree_erase(pd, node);
  1148. spin_lock(&pkt->lock);
  1149. bio_list_add(&pkt->orig_bios, bio);
  1150. pkt->write_size += bio->bi_size / CD_FRAMESIZE;
  1151. spin_unlock(&pkt->lock);
  1152. }
  1153. /* check write congestion marks, and if bio_queue_size is
  1154. below, wake up any waiters */
  1155. wakeup = (pd->write_congestion_on > 0
  1156. && pd->bio_queue_size <= pd->write_congestion_off);
  1157. spin_unlock(&pd->lock);
  1158. if (wakeup) {
  1159. clear_bdi_congested(&pd->disk->queue->backing_dev_info,
  1160. BLK_RW_ASYNC);
  1161. }
  1162. pkt->sleep_time = max(PACKET_WAIT_TIME, 1);
  1163. pkt_set_state(pkt, PACKET_WAITING_STATE);
  1164. atomic_set(&pkt->run_sm, 1);
  1165. spin_lock(&pd->cdrw.active_list_lock);
  1166. list_add(&pkt->list, &pd->cdrw.pkt_active_list);
  1167. spin_unlock(&pd->cdrw.active_list_lock);
  1168. return 1;
  1169. }
  1170. /*
  1171. * Assemble a bio to write one packet and queue the bio for processing
  1172. * by the underlying block device.
  1173. */
  1174. static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
  1175. {
  1176. struct bio *bio;
  1177. int f;
  1178. int frames_write;
  1179. struct bio_vec *bvec = pkt->w_bio->bi_io_vec;
  1180. for (f = 0; f < pkt->frames; f++) {
  1181. bvec[f].bv_page = pkt->pages[(f * CD_FRAMESIZE) / PAGE_SIZE];
  1182. bvec[f].bv_offset = (f * CD_FRAMESIZE) % PAGE_SIZE;
  1183. }
  1184. /*
  1185. * Fill-in bvec with data from orig_bios.
  1186. */
  1187. frames_write = 0;
  1188. spin_lock(&pkt->lock);
  1189. bio_list_for_each(bio, &pkt->orig_bios) {
  1190. int segment = bio->bi_idx;
  1191. int src_offs = 0;
  1192. int first_frame = (bio->bi_sector - pkt->sector) / (CD_FRAMESIZE >> 9);
  1193. int num_frames = bio->bi_size / CD_FRAMESIZE;
  1194. BUG_ON(first_frame < 0);
  1195. BUG_ON(first_frame + num_frames > pkt->frames);
  1196. for (f = first_frame; f < first_frame + num_frames; f++) {
  1197. struct bio_vec *src_bvl = bio_iovec_idx(bio, segment);
  1198. while (src_offs >= src_bvl->bv_len) {
  1199. src_offs -= src_bvl->bv_len;
  1200. segment++;
  1201. BUG_ON(segment >= bio->bi_vcnt);
  1202. src_bvl = bio_iovec_idx(bio, segment);
  1203. }
  1204. if (src_bvl->bv_len - src_offs >= CD_FRAMESIZE) {
  1205. bvec[f].bv_page = src_bvl->bv_page;
  1206. bvec[f].bv_offset = src_bvl->bv_offset + src_offs;
  1207. } else {
  1208. pkt_copy_bio_data(bio, segment, src_offs,
  1209. bvec[f].bv_page, bvec[f].bv_offset);
  1210. }
  1211. src_offs += CD_FRAMESIZE;
  1212. frames_write++;
  1213. }
  1214. }
  1215. pkt_set_state(pkt, PACKET_WRITE_WAIT_STATE);
  1216. spin_unlock(&pkt->lock);
  1217. VPRINTK("pkt_start_write: Writing %d frames for zone %llx\n",
  1218. frames_write, (unsigned long long)pkt->sector);
  1219. BUG_ON(frames_write != pkt->write_size);
  1220. if (test_bit(PACKET_MERGE_SEGS, &pd->flags) || (pkt->write_size < pkt->frames)) {
  1221. pkt_make_local_copy(pkt, bvec);
  1222. pkt->cache_valid = 1;
  1223. } else {
  1224. pkt->cache_valid = 0;
  1225. }
  1226. /* Start the write request */
  1227. bio_init(pkt->w_bio);
  1228. pkt->w_bio->bi_max_vecs = PACKET_MAX_SIZE;
  1229. pkt->w_bio->bi_sector = pkt->sector;
  1230. pkt->w_bio->bi_bdev = pd->bdev;
  1231. pkt->w_bio->bi_end_io = pkt_end_io_packet_write;
  1232. pkt->w_bio->bi_private = pkt;
  1233. pkt->w_bio->bi_io_vec = bvec;
  1234. pkt->w_bio->bi_destructor = pkt_bio_destructor;
  1235. for (f = 0; f < pkt->frames; f++)
  1236. if (!bio_add_page(pkt->w_bio, bvec[f].bv_page, CD_FRAMESIZE, bvec[f].bv_offset))
  1237. BUG();
  1238. VPRINTK(DRIVER_NAME": vcnt=%d\n", pkt->w_bio->bi_vcnt);
  1239. atomic_set(&pkt->io_wait, 1);
  1240. pkt->w_bio->bi_rw = WRITE;
  1241. pkt_queue_bio(pd, pkt->w_bio);
  1242. }
  1243. static void pkt_finish_packet(struct packet_data *pkt, int uptodate)
  1244. {
  1245. struct bio *bio;
  1246. if (!uptodate)
  1247. pkt->cache_valid = 0;
  1248. /* Finish all bios corresponding to this packet */
  1249. while ((bio = bio_list_pop(&pkt->orig_bios)))
  1250. bio_endio(bio, uptodate ? 0 : -EIO);
  1251. }
  1252. static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data *pkt)
  1253. {
  1254. int uptodate;
  1255. VPRINTK("run_state_machine: pkt %d\n", pkt->id);
  1256. for (;;) {
  1257. switch (pkt->state) {
  1258. case PACKET_WAITING_STATE:
  1259. if ((pkt->write_size < pkt->frames) && (pkt->sleep_time > 0))
  1260. return;
  1261. pkt->sleep_time = 0;
  1262. pkt_gather_data(pd, pkt);
  1263. pkt_set_state(pkt, PACKET_READ_WAIT_STATE);
  1264. break;
  1265. case PACKET_READ_WAIT_STATE:
  1266. if (atomic_read(&pkt->io_wait) > 0)
  1267. return;
  1268. if (atomic_read(&pkt->io_errors) > 0) {
  1269. pkt_set_state(pkt, PACKET_RECOVERY_STATE);
  1270. } else {
  1271. pkt_start_write(pd, pkt);
  1272. }
  1273. break;
  1274. case PACKET_WRITE_WAIT_STATE:
  1275. if (atomic_read(&pkt->io_wait) > 0)
  1276. return;
  1277. if (test_bit(BIO_UPTODATE, &pkt->w_bio->bi_flags)) {
  1278. pkt_set_state(pkt, PACKET_FINISHED_STATE);
  1279. } else {
  1280. pkt_set_state(pkt, PACKET_RECOVERY_STATE);
  1281. }
  1282. break;
  1283. case PACKET_RECOVERY_STATE:
  1284. if (pkt_start_recovery(pkt)) {
  1285. pkt_start_write(pd, pkt);
  1286. } else {
  1287. VPRINTK("No recovery possible\n");
  1288. pkt_set_state(pkt, PACKET_FINISHED_STATE);
  1289. }
  1290. break;
  1291. case PACKET_FINISHED_STATE:
  1292. uptodate = test_bit(BIO_UPTODATE, &pkt->w_bio->bi_flags);
  1293. pkt_finish_packet(pkt, uptodate);
  1294. return;
  1295. default:
  1296. BUG();
  1297. break;
  1298. }
  1299. }
  1300. }
  1301. static void pkt_handle_packets(struct pktcdvd_device *pd)
  1302. {
  1303. struct packet_data *pkt, *next;
  1304. VPRINTK("pkt_handle_packets\n");
  1305. /*
  1306. * Run state machine for active packets
  1307. */
  1308. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  1309. if (atomic_read(&pkt->run_sm) > 0) {
  1310. atomic_set(&pkt->run_sm, 0);
  1311. pkt_run_state_machine(pd, pkt);
  1312. }
  1313. }
  1314. /*
  1315. * Move no longer active packets to the free list
  1316. */
  1317. spin_lock(&pd->cdrw.active_list_lock);
  1318. list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_active_list, list) {
  1319. if (pkt->state == PACKET_FINISHED_STATE) {
  1320. list_del(&pkt->list);
  1321. pkt_put_packet_data(pd, pkt);
  1322. pkt_set_state(pkt, PACKET_IDLE_STATE);
  1323. atomic_set(&pd->scan_queue, 1);
  1324. }
  1325. }
  1326. spin_unlock(&pd->cdrw.active_list_lock);
  1327. }
  1328. static void pkt_count_states(struct pktcdvd_device *pd, int *states)
  1329. {
  1330. struct packet_data *pkt;
  1331. int i;
  1332. for (i = 0; i < PACKET_NUM_STATES; i++)
  1333. states[i] = 0;
  1334. spin_lock(&pd->cdrw.active_list_lock);
  1335. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  1336. states[pkt->state]++;
  1337. }
  1338. spin_unlock(&pd->cdrw.active_list_lock);
  1339. }
  1340. /*
  1341. * kcdrwd is woken up when writes have been queued for one of our
  1342. * registered devices
  1343. */
  1344. static int kcdrwd(void *foobar)
  1345. {
  1346. struct pktcdvd_device *pd = foobar;
  1347. struct packet_data *pkt;
  1348. long min_sleep_time, residue;
  1349. set_user_nice(current, -20);
  1350. set_freezable();
  1351. for (;;) {
  1352. DECLARE_WAITQUEUE(wait, current);
  1353. /*
  1354. * Wait until there is something to do
  1355. */
  1356. add_wait_queue(&pd->wqueue, &wait);
  1357. for (;;) {
  1358. set_current_state(TASK_INTERRUPTIBLE);
  1359. /* Check if we need to run pkt_handle_queue */
  1360. if (atomic_read(&pd->scan_queue) > 0)
  1361. goto work_to_do;
  1362. /* Check if we need to run the state machine for some packet */
  1363. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  1364. if (atomic_read(&pkt->run_sm) > 0)
  1365. goto work_to_do;
  1366. }
  1367. /* Check if we need to process the iosched queues */
  1368. if (atomic_read(&pd->iosched.attention) != 0)
  1369. goto work_to_do;
  1370. /* Otherwise, go to sleep */
  1371. if (PACKET_DEBUG > 1) {
  1372. int states[PACKET_NUM_STATES];
  1373. pkt_count_states(pd, states);
  1374. VPRINTK("kcdrwd: i:%d ow:%d rw:%d ww:%d rec:%d fin:%d\n",
  1375. states[0], states[1], states[2], states[3],
  1376. states[4], states[5]);
  1377. }
  1378. min_sleep_time = MAX_SCHEDULE_TIMEOUT;
  1379. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  1380. if (pkt->sleep_time && pkt->sleep_time < min_sleep_time)
  1381. min_sleep_time = pkt->sleep_time;
  1382. }
  1383. generic_unplug_device(bdev_get_queue(pd->bdev));
  1384. VPRINTK("kcdrwd: sleeping\n");
  1385. residue = schedule_timeout(min_sleep_time);
  1386. VPRINTK("kcdrwd: wake up\n");
  1387. /* make swsusp happy with our thread */
  1388. try_to_freeze();
  1389. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  1390. if (!pkt->sleep_time)
  1391. continue;
  1392. pkt->sleep_time -= min_sleep_time - residue;
  1393. if (pkt->sleep_time <= 0) {
  1394. pkt->sleep_time = 0;
  1395. atomic_inc(&pkt->run_sm);
  1396. }
  1397. }
  1398. if (kthread_should_stop())
  1399. break;
  1400. }
  1401. work_to_do:
  1402. set_current_state(TASK_RUNNING);
  1403. remove_wait_queue(&pd->wqueue, &wait);
  1404. if (kthread_should_stop())
  1405. break;
  1406. /*
  1407. * if pkt_handle_queue returns true, we can queue
  1408. * another request.
  1409. */
  1410. while (pkt_handle_queue(pd))
  1411. ;
  1412. /*
  1413. * Handle packet state machine
  1414. */
  1415. pkt_handle_packets(pd);
  1416. /*
  1417. * Handle iosched queues
  1418. */
  1419. pkt_iosched_process_queue(pd);
  1420. }
  1421. return 0;
  1422. }
  1423. static void pkt_print_settings(struct pktcdvd_device *pd)
  1424. {
  1425. printk(DRIVER_NAME": %s packets, ", pd->settings.fp ? "Fixed" : "Variable");
  1426. printk("%u blocks, ", pd->settings.size >> 2);
  1427. printk("Mode-%c disc\n", pd->settings.block_mode == 8 ? '1' : '2');
  1428. }
  1429. static int pkt_mode_sense(struct pktcdvd_device *pd, struct packet_command *cgc, int page_code, int page_control)
  1430. {
  1431. memset(cgc->cmd, 0, sizeof(cgc->cmd));
  1432. cgc->cmd[0] = GPCMD_MODE_SENSE_10;
  1433. cgc->cmd[2] = page_code | (page_control << 6);
  1434. cgc->cmd[7] = cgc->buflen >> 8;
  1435. cgc->cmd[8] = cgc->buflen & 0xff;
  1436. cgc->data_direction = CGC_DATA_READ;
  1437. return pkt_generic_packet(pd, cgc);
  1438. }
  1439. static int pkt_mode_select(struct pktcdvd_device *pd, struct packet_command *cgc)
  1440. {
  1441. memset(cgc->cmd, 0, sizeof(cgc->cmd));
  1442. memset(cgc->buffer, 0, 2);
  1443. cgc->cmd[0] = GPCMD_MODE_SELECT_10;
  1444. cgc->cmd[1] = 0x10; /* PF */
  1445. cgc->cmd[7] = cgc->buflen >> 8;
  1446. cgc->cmd[8] = cgc->buflen & 0xff;
  1447. cgc->data_direction = CGC_DATA_WRITE;
  1448. return pkt_generic_packet(pd, cgc);
  1449. }
  1450. static int pkt_get_disc_info(struct pktcdvd_device *pd, disc_information *di)
  1451. {
  1452. struct packet_command cgc;
  1453. int ret;
  1454. /* set up command and get the disc info */
  1455. init_cdrom_command(&cgc, di, sizeof(*di), CGC_DATA_READ);
  1456. cgc.cmd[0] = GPCMD_READ_DISC_INFO;
  1457. cgc.cmd[8] = cgc.buflen = 2;
  1458. cgc.quiet = 1;
  1459. if ((ret = pkt_generic_packet(pd, &cgc)))
  1460. return ret;
  1461. /* not all drives have the same disc_info length, so requeue
  1462. * packet with the length the drive tells us it can supply
  1463. */
  1464. cgc.buflen = be16_to_cpu(di->disc_information_length) +
  1465. sizeof(di->disc_information_length);
  1466. if (cgc.buflen > sizeof(disc_information))
  1467. cgc.buflen = sizeof(disc_information);
  1468. cgc.cmd[8] = cgc.buflen;
  1469. return pkt_generic_packet(pd, &cgc);
  1470. }
  1471. static int pkt_get_track_info(struct pktcdvd_device *pd, __u16 track, __u8 type, track_information *ti)
  1472. {
  1473. struct packet_command cgc;
  1474. int ret;
  1475. init_cdrom_command(&cgc, ti, 8, CGC_DATA_READ);
  1476. cgc.cmd[0] = GPCMD_READ_TRACK_RZONE_INFO;
  1477. cgc.cmd[1] = type & 3;
  1478. cgc.cmd[4] = (track & 0xff00) >> 8;
  1479. cgc.cmd[5] = track & 0xff;
  1480. cgc.cmd[8] = 8;
  1481. cgc.quiet = 1;
  1482. if ((ret = pkt_generic_packet(pd, &cgc)))
  1483. return ret;
  1484. cgc.buflen = be16_to_cpu(ti->track_information_length) +
  1485. sizeof(ti->track_information_length);
  1486. if (cgc.buflen > sizeof(track_information))
  1487. cgc.buflen = sizeof(track_information);
  1488. cgc.cmd[8] = cgc.buflen;
  1489. return pkt_generic_packet(pd, &cgc);
  1490. }
  1491. static noinline_for_stack int pkt_get_last_written(struct pktcdvd_device *pd,
  1492. long *last_written)
  1493. {
  1494. disc_information di;
  1495. track_information ti;
  1496. __u32 last_track;
  1497. int ret = -1;
  1498. if ((ret = pkt_get_disc_info(pd, &di)))
  1499. return ret;
  1500. last_track = (di.last_track_msb << 8) | di.last_track_lsb;
  1501. if ((ret = pkt_get_track_info(pd, last_track, 1, &ti)))
  1502. return ret;
  1503. /* if this track is blank, try the previous. */
  1504. if (ti.blank) {
  1505. last_track--;
  1506. if ((ret = pkt_get_track_info(pd, last_track, 1, &ti)))
  1507. return ret;
  1508. }
  1509. /* if last recorded field is valid, return it. */
  1510. if (ti.lra_v) {
  1511. *last_written = be32_to_cpu(ti.last_rec_address);
  1512. } else {
  1513. /* make it up instead */
  1514. *last_written = be32_to_cpu(ti.track_start) +
  1515. be32_to_cpu(ti.track_size);
  1516. if (ti.free_blocks)
  1517. *last_written -= (be32_to_cpu(ti.free_blocks) + 7);
  1518. }
  1519. return 0;
  1520. }
  1521. /*
  1522. * write mode select package based on pd->settings
  1523. */
  1524. static noinline_for_stack int pkt_set_write_settings(struct pktcdvd_device *pd)
  1525. {
  1526. struct packet_command cgc;
  1527. struct request_sense sense;
  1528. write_param_page *wp;
  1529. char buffer[128];
  1530. int ret, size;
  1531. /* doesn't apply to DVD+RW or DVD-RAM */
  1532. if ((pd->mmc3_profile == 0x1a) || (pd->mmc3_profile == 0x12))
  1533. return 0;
  1534. memset(buffer, 0, sizeof(buffer));
  1535. init_cdrom_command(&cgc, buffer, sizeof(*wp), CGC_DATA_READ);
  1536. cgc.sense = &sense;
  1537. if ((ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0))) {
  1538. pkt_dump_sense(&cgc);
  1539. return ret;
  1540. }
  1541. size = 2 + ((buffer[0] << 8) | (buffer[1] & 0xff));
  1542. pd->mode_offset = (buffer[6] << 8) | (buffer[7] & 0xff);
  1543. if (size > sizeof(buffer))
  1544. size = sizeof(buffer);
  1545. /*
  1546. * now get it all
  1547. */
  1548. init_cdrom_command(&cgc, buffer, size, CGC_DATA_READ);
  1549. cgc.sense = &sense;
  1550. if ((ret = pkt_mode_sense(pd, &cgc, GPMODE_WRITE_PARMS_PAGE, 0))) {
  1551. pkt_dump_sense(&cgc);
  1552. return ret;
  1553. }
  1554. /*
  1555. * write page is offset header + block descriptor length
  1556. */
  1557. wp = (write_param_page *) &buffer[sizeof(struct mode_page_header) + pd->mode_offset];
  1558. wp->fp = pd->settings.fp;
  1559. wp->track_mode = pd->settings.track_mode;
  1560. wp->write_type = pd->settings.write_type;
  1561. wp->data_block_type = pd->settings.block_mode;
  1562. wp->multi_session = 0;
  1563. #ifdef PACKET_USE_LS
  1564. wp->link_size = 7;
  1565. wp->ls_v = 1;
  1566. #endif
  1567. if (wp->data_block_type == PACKET_BLOCK_MODE1) {
  1568. wp->session_format = 0;
  1569. wp->subhdr2 = 0x20;
  1570. } else if (wp->data_block_type == PACKET_BLOCK_MODE2) {
  1571. wp->session_format = 0x20;
  1572. wp->subhdr2 = 8;
  1573. #if 0
  1574. wp->mcn[0] = 0x80;
  1575. memcpy(&wp->mcn[1], PACKET_MCN, sizeof(wp->mcn) - 1);
  1576. #endif
  1577. } else {
  1578. /*
  1579. * paranoia
  1580. */
  1581. printk(DRIVER_NAME": write mode wrong %d\n", wp->data_block_type);
  1582. return 1;
  1583. }
  1584. wp->packet_size = cpu_to_be32(pd->settings.size >> 2);
  1585. cgc.buflen = cgc.cmd[8] = size;
  1586. if ((ret = pkt_mode_select(pd, &cgc))) {
  1587. pkt_dump_sense(&cgc);
  1588. return ret;
  1589. }
  1590. pkt_print_settings(pd);
  1591. return 0;
  1592. }
  1593. /*
  1594. * 1 -- we can write to this track, 0 -- we can't
  1595. */
  1596. static int pkt_writable_track(struct pktcdvd_device *pd, track_information *ti)
  1597. {
  1598. switch (pd->mmc3_profile) {
  1599. case 0x1a: /* DVD+RW */
  1600. case 0x12: /* DVD-RAM */
  1601. /* The track is always writable on DVD+RW/DVD-RAM */
  1602. return 1;
  1603. default:
  1604. break;
  1605. }
  1606. if (!ti->packet || !ti->fp)
  1607. return 0;
  1608. /*
  1609. * "good" settings as per Mt Fuji.
  1610. */
  1611. if (ti->rt == 0 && ti->blank == 0)
  1612. return 1;
  1613. if (ti->rt == 0 && ti->blank == 1)
  1614. return 1;
  1615. if (ti->rt == 1 && ti->blank == 0)
  1616. return 1;
  1617. printk(DRIVER_NAME": bad state %d-%d-%d\n", ti->rt, ti->blank, ti->packet);
  1618. return 0;
  1619. }
  1620. /*
  1621. * 1 -- we can write to this disc, 0 -- we can't
  1622. */
  1623. static int pkt_writable_disc(struct pktcdvd_device *pd, disc_information *di)
  1624. {
  1625. switch (pd->mmc3_profile) {
  1626. case 0x0a: /* CD-RW */
  1627. case 0xffff: /* MMC3 not supported */
  1628. break;
  1629. case 0x1a: /* DVD+RW */
  1630. case 0x13: /* DVD-RW */
  1631. case 0x12: /* DVD-RAM */
  1632. return 1;
  1633. default:
  1634. VPRINTK(DRIVER_NAME": Wrong disc profile (%x)\n", pd->mmc3_profile);
  1635. return 0;
  1636. }
  1637. /*
  1638. * for disc type 0xff we should probably reserve a new track.
  1639. * but i'm not sure, should we leave this to user apps? probably.
  1640. */
  1641. if (di->disc_type == 0xff) {
  1642. printk(DRIVER_NAME": Unknown disc. No track?\n");
  1643. return 0;
  1644. }
  1645. if (di->disc_type != 0x20 && di->disc_type != 0) {
  1646. printk(DRIVER_NAME": Wrong disc type (%x)\n", di->disc_type);
  1647. return 0;
  1648. }
  1649. if (di->erasable == 0) {
  1650. printk(DRIVER_NAME": Disc not erasable\n");
  1651. return 0;
  1652. }
  1653. if (di->border_status == PACKET_SESSION_RESERVED) {
  1654. printk(DRIVER_NAME": Can't write to last track (reserved)\n");
  1655. return 0;
  1656. }
  1657. return 1;
  1658. }
  1659. static noinline_for_stack int pkt_probe_settings(struct pktcdvd_device *pd)
  1660. {
  1661. struct packet_command cgc;
  1662. unsigned char buf[12];
  1663. disc_information di;
  1664. track_information ti;
  1665. int ret, track;
  1666. init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
  1667. cgc.cmd[0] = GPCMD_GET_CONFIGURATION;
  1668. cgc.cmd[8] = 8;
  1669. ret = pkt_generic_packet(pd, &cgc);
  1670. pd->mmc3_profile = ret ? 0xffff : buf[6] << 8 | buf[7];
  1671. memset(&di, 0, sizeof(disc_information));
  1672. memset(&ti, 0, sizeof(track_information));
  1673. if ((ret = pkt_get_disc_info(pd, &di))) {
  1674. printk("failed get_disc\n");
  1675. return ret;
  1676. }
  1677. if (!pkt_writable_disc(pd, &di))
  1678. return -EROFS;
  1679. pd->type = di.erasable ? PACKET_CDRW : PACKET_CDR;
  1680. track = 1; /* (di.last_track_msb << 8) | di.last_track_lsb; */
  1681. if ((ret = pkt_get_track_info(pd, track, 1, &ti))) {
  1682. printk(DRIVER_NAME": failed get_track\n");
  1683. return ret;
  1684. }
  1685. if (!pkt_writable_track(pd, &ti)) {
  1686. printk(DRIVER_NAME": can't write to this track\n");
  1687. return -EROFS;
  1688. }
  1689. /*
  1690. * we keep packet size in 512 byte units, makes it easier to
  1691. * deal with request calculations.
  1692. */
  1693. pd->settings.size = be32_to_cpu(ti.fixed_packet_size) << 2;
  1694. if (pd->settings.size == 0) {
  1695. printk(DRIVER_NAME": detected zero packet size!\n");
  1696. return -ENXIO;
  1697. }
  1698. if (pd->settings.size > PACKET_MAX_SECTORS) {
  1699. printk(DRIVER_NAME": packet size is too big\n");
  1700. return -EROFS;
  1701. }
  1702. pd->settings.fp = ti.fp;
  1703. pd->offset = (be32_to_cpu(ti.track_start) << 2) & (pd->settings.size - 1);
  1704. if (ti.nwa_v) {
  1705. pd->nwa = be32_to_cpu(ti.next_writable);
  1706. set_bit(PACKET_NWA_VALID, &pd->flags);
  1707. }
  1708. /*
  1709. * in theory we could use lra on -RW media as well and just zero
  1710. * blocks that haven't been written yet, but in practice that
  1711. * is just a no-go. we'll use that for -R, naturally.
  1712. */
  1713. if (ti.lra_v) {
  1714. pd->lra = be32_to_cpu(ti.last_rec_address);
  1715. set_bit(PACKET_LRA_VALID, &pd->flags);
  1716. } else {
  1717. pd->lra = 0xffffffff;
  1718. set_bit(PACKET_LRA_VALID, &pd->flags);
  1719. }
  1720. /*
  1721. * fine for now
  1722. */
  1723. pd->settings.link_loss = 7;
  1724. pd->settings.write_type = 0; /* packet */
  1725. pd->settings.track_mode = ti.track_mode;
  1726. /*
  1727. * mode1 or mode2 disc
  1728. */
  1729. switch (ti.data_mode) {
  1730. case PACKET_MODE1:
  1731. pd->settings.block_mode = PACKET_BLOCK_MODE1;
  1732. break;
  1733. case PACKET_MODE2:
  1734. pd->settings.block_mode = PACKET_BLOCK_MODE2;
  1735. break;
  1736. default:
  1737. printk(DRIVER_NAME": unknown data mode\n");
  1738. return -EROFS;
  1739. }
  1740. return 0;
  1741. }
  1742. /*
  1743. * enable/disable write caching on drive
  1744. */
  1745. static noinline_for_stack int pkt_write_caching(struct pktcdvd_device *pd,
  1746. int set)
  1747. {
  1748. struct packet_command cgc;
  1749. struct request_sense sense;
  1750. unsigned char buf[64];
  1751. int ret;
  1752. init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_READ);
  1753. cgc.sense = &sense;
  1754. cgc.buflen = pd->mode_offset + 12;
  1755. /*
  1756. * caching mode page might not be there, so quiet this command
  1757. */
  1758. cgc.quiet = 1;
  1759. if ((ret = pkt_mode_sense(pd, &cgc, GPMODE_WCACHING_PAGE, 0)))
  1760. return ret;
  1761. buf[pd->mode_offset + 10] |= (!!set << 2);
  1762. cgc.buflen = cgc.cmd[8] = 2 + ((buf[0] << 8) | (buf[1] & 0xff));
  1763. ret = pkt_mode_select(pd, &cgc);
  1764. if (ret) {
  1765. printk(DRIVER_NAME": write caching control failed\n");
  1766. pkt_dump_sense(&cgc);
  1767. } else if (!ret && set)
  1768. printk(DRIVER_NAME": enabled write caching on %s\n", pd->name);
  1769. return ret;
  1770. }
  1771. static int pkt_lock_door(struct pktcdvd_device *pd, int lockflag)
  1772. {
  1773. struct packet_command cgc;
  1774. init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
  1775. cgc.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
  1776. cgc.cmd[4] = lockflag ? 1 : 0;
  1777. return pkt_generic_packet(pd, &cgc);
  1778. }
  1779. /*
  1780. * Returns drive maximum write speed
  1781. */
  1782. static noinline_for_stack int pkt_get_max_speed(struct pktcdvd_device *pd,
  1783. unsigned *write_speed)
  1784. {
  1785. struct packet_command cgc;
  1786. struct request_sense sense;
  1787. unsigned char buf[256+18];
  1788. unsigned char *cap_buf;
  1789. int ret, offset;
  1790. cap_buf = &buf[sizeof(struct mode_page_header) + pd->mode_offset];
  1791. init_cdrom_command(&cgc, buf, sizeof(buf), CGC_DATA_UNKNOWN);
  1792. cgc.sense = &sense;
  1793. ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
  1794. if (ret) {
  1795. cgc.buflen = pd->mode_offset + cap_buf[1] + 2 +
  1796. sizeof(struct mode_page_header);
  1797. ret = pkt_mode_sense(pd, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
  1798. if (ret) {
  1799. pkt_dump_sense(&cgc);
  1800. return ret;
  1801. }
  1802. }
  1803. offset = 20; /* Obsoleted field, used by older drives */
  1804. if (cap_buf[1] >= 28)
  1805. offset = 28; /* Current write speed selected */
  1806. if (cap_buf[1] >= 30) {
  1807. /* If the drive reports at least one "Logical Unit Write
  1808. * Speed Performance Descriptor Block", use the information
  1809. * in the first block. (contains the highest speed)
  1810. */
  1811. int num_spdb = (cap_buf[30] << 8) + cap_buf[31];
  1812. if (num_spdb > 0)
  1813. offset = 34;
  1814. }
  1815. *write_speed = (cap_buf[offset] << 8) | cap_buf[offset + 1];
  1816. return 0;
  1817. }
  1818. /* These tables from cdrecord - I don't have orange book */
  1819. /* standard speed CD-RW (1-4x) */
  1820. static char clv_to_speed[16] = {
  1821. /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */
  1822. 0, 2, 4, 6, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  1823. };
  1824. /* high speed CD-RW (-10x) */
  1825. static char hs_clv_to_speed[16] = {
  1826. /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */
  1827. 0, 2, 4, 6, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  1828. };
  1829. /* ultra high speed CD-RW */
  1830. static char us_clv_to_speed[16] = {
  1831. /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */
  1832. 0, 2, 4, 8, 0, 0,16, 0,24,32,40,48, 0, 0, 0, 0
  1833. };
  1834. /*
  1835. * reads the maximum media speed from ATIP
  1836. */
  1837. static noinline_for_stack int pkt_media_speed(struct pktcdvd_device *pd,
  1838. unsigned *speed)
  1839. {
  1840. struct packet_command cgc;
  1841. struct request_sense sense;
  1842. unsigned char buf[64];
  1843. unsigned int size, st, sp;
  1844. int ret;
  1845. init_cdrom_command(&cgc, buf, 2, CGC_DATA_READ);
  1846. cgc.sense = &sense;
  1847. cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
  1848. cgc.cmd[1] = 2;
  1849. cgc.cmd[2] = 4; /* READ ATIP */
  1850. cgc.cmd[8] = 2;
  1851. ret = pkt_generic_packet(pd, &cgc);
  1852. if (ret) {
  1853. pkt_dump_sense(&cgc);
  1854. return ret;
  1855. }
  1856. size = ((unsigned int) buf[0]<<8) + buf[1] + 2;
  1857. if (size > sizeof(buf))
  1858. size = sizeof(buf);
  1859. init_cdrom_command(&cgc, buf, size, CGC_DATA_READ);
  1860. cgc.sense = &sense;
  1861. cgc.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
  1862. cgc.cmd[1] = 2;
  1863. cgc.cmd[2] = 4;
  1864. cgc.cmd[8] = size;
  1865. ret = pkt_generic_packet(pd, &cgc);
  1866. if (ret) {
  1867. pkt_dump_sense(&cgc);
  1868. return ret;
  1869. }
  1870. if (!(buf[6] & 0x40)) {
  1871. printk(DRIVER_NAME": Disc type is not CD-RW\n");
  1872. return 1;
  1873. }
  1874. if (!(buf[6] & 0x4)) {
  1875. printk(DRIVER_NAME": A1 values on media are not valid, maybe not CDRW?\n");
  1876. return 1;
  1877. }
  1878. st = (buf[6] >> 3) & 0x7; /* disc sub-type */
  1879. sp = buf[16] & 0xf; /* max speed from ATIP A1 field */
  1880. /* Info from cdrecord */
  1881. switch (st) {
  1882. case 0: /* standard speed */
  1883. *speed = clv_to_speed[sp];
  1884. break;
  1885. case 1: /* high speed */
  1886. *speed = hs_clv_to_speed[sp];
  1887. break;
  1888. case 2: /* ultra high speed */
  1889. *speed = us_clv_to_speed[sp];
  1890. break;
  1891. default:
  1892. printk(DRIVER_NAME": Unknown disc sub-type %d\n",st);
  1893. return 1;
  1894. }
  1895. if (*speed) {
  1896. printk(DRIVER_NAME": Max. media speed: %d\n",*speed);
  1897. return 0;
  1898. } else {
  1899. printk(DRIVER_NAME": Unknown speed %d for sub-type %d\n",sp,st);
  1900. return 1;
  1901. }
  1902. }
  1903. static noinline_for_stack int pkt_perform_opc(struct pktcdvd_device *pd)
  1904. {
  1905. struct packet_command cgc;
  1906. struct request_sense sense;
  1907. int ret;
  1908. VPRINTK(DRIVER_NAME": Performing OPC\n");
  1909. init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
  1910. cgc.sense = &sense;
  1911. cgc.timeout = 60*HZ;
  1912. cgc.cmd[0] = GPCMD_SEND_OPC;
  1913. cgc.cmd[1] = 1;
  1914. if ((ret = pkt_generic_packet(pd, &cgc)))
  1915. pkt_dump_sense(&cgc);
  1916. return ret;
  1917. }
  1918. static int pkt_open_write(struct pktcdvd_device *pd)
  1919. {
  1920. int ret;
  1921. unsigned int write_speed, media_write_speed, read_speed;
  1922. if ((ret = pkt_probe_settings(pd))) {
  1923. VPRINTK(DRIVER_NAME": %s failed probe\n", pd->name);
  1924. return ret;
  1925. }
  1926. if ((ret = pkt_set_write_settings(pd))) {
  1927. DPRINTK(DRIVER_NAME": %s failed saving write settings\n", pd->name);
  1928. return -EIO;
  1929. }
  1930. pkt_write_caching(pd, USE_WCACHING);
  1931. if ((ret = pkt_get_max_speed(pd, &write_speed)))
  1932. write_speed = 16 * 177;
  1933. switch (pd->mmc3_profile) {
  1934. case 0x13: /* DVD-RW */
  1935. case 0x1a: /* DVD+RW */
  1936. case 0x12: /* DVD-RAM */
  1937. DPRINTK(DRIVER_NAME": write speed %ukB/s\n", write_speed);
  1938. break;
  1939. default:
  1940. if ((ret = pkt_media_speed(pd, &media_write_speed)))
  1941. media_write_speed = 16;
  1942. write_speed = min(write_speed, media_write_speed * 177);
  1943. DPRINTK(DRIVER_NAME": write speed %ux\n", write_speed / 176);
  1944. break;
  1945. }
  1946. read_speed = write_speed;
  1947. if ((ret = pkt_set_speed(pd, write_speed, read_speed))) {
  1948. DPRINTK(DRIVER_NAME": %s couldn't set write speed\n", pd->name);
  1949. return -EIO;
  1950. }
  1951. pd->write_speed = write_speed;
  1952. pd->read_speed = read_speed;
  1953. if ((ret = pkt_perform_opc(pd))) {
  1954. DPRINTK(DRIVER_NAME": %s Optimum Power Calibration failed\n", pd->name);
  1955. }
  1956. return 0;
  1957. }
  1958. /*
  1959. * called at open time.
  1960. */
  1961. static int pkt_open_dev(struct pktcdvd_device *pd, fmode_t write)
  1962. {
  1963. int ret;
  1964. long lba;
  1965. struct request_queue *q;
  1966. /*
  1967. * We need to re-open the cdrom device without O_NONBLOCK to be able
  1968. * to read/write from/to it. It is already opened in O_NONBLOCK mode
  1969. * so bdget() can't fail.
  1970. */
  1971. bdget(pd->bdev->bd_dev);
  1972. if ((ret = blkdev_get(pd->bdev, FMODE_READ)))
  1973. goto out;
  1974. if ((ret = bd_claim(pd->bdev, pd)))
  1975. goto out_putdev;
  1976. if ((ret = pkt_get_last_written(pd, &lba))) {
  1977. printk(DRIVER_NAME": pkt_get_last_written failed\n");
  1978. goto out_unclaim;
  1979. }
  1980. set_capacity(pd->disk, lba << 2);
  1981. set_capacity(pd->bdev->bd_disk, lba << 2);
  1982. bd_set_size(pd->bdev, (loff_t)lba << 11);
  1983. q = bdev_get_queue(pd->bdev);
  1984. if (write) {
  1985. if ((ret = pkt_open_write(pd)))
  1986. goto out_unclaim;
  1987. /*
  1988. * Some CDRW drives can not handle writes larger than one packet,
  1989. * even if the size is a multiple of the packet size.
  1990. */
  1991. spin_lock_irq(q->queue_lock);
  1992. blk_queue_max_sectors(q, pd->settings.size);
  1993. spin_unlock_irq(q->queue_lock);
  1994. set_bit(PACKET_WRITABLE, &pd->flags);
  1995. } else {
  1996. pkt_set_speed(pd, MAX_SPEED, MAX_SPEED);
  1997. clear_bit(PACKET_WRITABLE, &pd->flags);
  1998. }
  1999. if ((ret = pkt_set_segment_merging(pd, q)))
  2000. goto out_unclaim;
  2001. if (write) {
  2002. if (!pkt_grow_pktlist(pd, CONFIG_CDROM_PKTCDVD_BUFFERS)) {
  2003. printk(DRIVER_NAME": not enough memory for buffers\n");
  2004. ret = -ENOMEM;
  2005. goto out_unclaim;
  2006. }
  2007. printk(DRIVER_NAME": %lukB available on disc\n", lba << 1);
  2008. }
  2009. return 0;
  2010. out_unclaim:
  2011. bd_release(pd->bdev);
  2012. out_putdev:
  2013. blkdev_put(pd->bdev, FMODE_READ);
  2014. out:
  2015. return ret;
  2016. }
  2017. /*
  2018. * called when the device is closed. makes sure that the device flushes
  2019. * the internal cache before we close.
  2020. */
  2021. static void pkt_release_dev(struct pktcdvd_device *pd, int flush)
  2022. {
  2023. if (flush && pkt_flush_cache(pd))
  2024. DPRINTK(DRIVER_NAME": %s not flushing cache\n", pd->name);
  2025. pkt_lock_door(pd, 0);
  2026. pkt_set_speed(pd, MAX_SPEED, MAX_SPEED);
  2027. bd_release(pd->bdev);
  2028. blkdev_put(pd->bdev, FMODE_READ);
  2029. pkt_shrink_pktlist(pd);
  2030. }
  2031. static struct pktcdvd_device *pkt_find_dev_from_minor(int dev_minor)
  2032. {
  2033. if (dev_minor >= MAX_WRITERS)
  2034. return NULL;
  2035. return pkt_devs[dev_minor];
  2036. }
  2037. static int pkt_open(struct block_device *bdev, fmode_t mode)
  2038. {
  2039. struct pktcdvd_device *pd = NULL;
  2040. int ret;
  2041. VPRINTK(DRIVER_NAME": entering open\n");
  2042. mutex_lock(&ctl_mutex);
  2043. pd = pkt_find_dev_from_minor(MINOR(bdev->bd_dev));
  2044. if (!pd) {
  2045. ret = -ENODEV;
  2046. goto out;
  2047. }
  2048. BUG_ON(pd->refcnt < 0);
  2049. pd->refcnt++;
  2050. if (pd->refcnt > 1) {
  2051. if ((mode & FMODE_WRITE) &&
  2052. !test_bit(PACKET_WRITABLE, &pd->flags)) {
  2053. ret = -EBUSY;
  2054. goto out_dec;
  2055. }
  2056. } else {
  2057. ret = pkt_open_dev(pd, mode & FMODE_WRITE);
  2058. if (ret)
  2059. goto out_dec;
  2060. /*
  2061. * needed here as well, since ext2 (among others) may change
  2062. * the blocksize at mount time
  2063. */
  2064. set_blocksize(bdev, CD_FRAMESIZE);
  2065. }
  2066. mutex_unlock(&ctl_mutex);
  2067. return 0;
  2068. out_dec:
  2069. pd->refcnt--;
  2070. out:
  2071. VPRINTK(DRIVER_NAME": failed open (%d)\n", ret);
  2072. mutex_unlock(&ctl_mutex);
  2073. return ret;
  2074. }
  2075. static int pkt_close(struct gendisk *disk, fmode_t mode)
  2076. {
  2077. struct pktcdvd_device *pd = disk->private_data;
  2078. int ret = 0;
  2079. mutex_lock(&ctl_mutex);
  2080. pd->refcnt--;
  2081. BUG_ON(pd->refcnt < 0);
  2082. if (pd->refcnt == 0) {
  2083. int flush = test_bit(PACKET_WRITABLE, &pd->flags);
  2084. pkt_release_dev(pd, flush);
  2085. }
  2086. mutex_unlock(&ctl_mutex);
  2087. return ret;
  2088. }
  2089. static void pkt_end_io_read_cloned(struct bio *bio, int err)
  2090. {
  2091. struct packet_stacked_data *psd = bio->bi_private;
  2092. struct pktcdvd_device *pd = psd->pd;
  2093. bio_put(bio);
  2094. bio_endio(psd->bio, err);
  2095. mempool_free(psd, psd_pool);
  2096. pkt_bio_finished(pd);
  2097. }
  2098. static int pkt_make_request(struct request_queue *q, struct bio *bio)
  2099. {
  2100. struct pktcdvd_device *pd;
  2101. char b[BDEVNAME_SIZE];
  2102. sector_t zone;
  2103. struct packet_data *pkt;
  2104. int was_empty, blocked_bio;
  2105. struct pkt_rb_node *node;
  2106. pd = q->queuedata;
  2107. if (!pd) {
  2108. printk(DRIVER_NAME": %s incorrect request queue\n", bdevname(bio->bi_bdev, b));
  2109. goto end_io;
  2110. }
  2111. /*
  2112. * Clone READ bios so we can have our own bi_end_io callback.
  2113. */
  2114. if (bio_data_dir(bio) == READ) {
  2115. struct bio *cloned_bio = bio_clone(bio, GFP_NOIO);
  2116. struct packet_stacked_data *psd = mempool_alloc(psd_pool, GFP_NOIO);
  2117. psd->pd = pd;
  2118. psd->bio = bio;
  2119. cloned_bio->bi_bdev = pd->bdev;
  2120. cloned_bio->bi_private = psd;
  2121. cloned_bio->bi_end_io = pkt_end_io_read_cloned;
  2122. pd->stats.secs_r += bio->bi_size >> 9;
  2123. pkt_queue_bio(pd, cloned_bio);
  2124. return 0;
  2125. }
  2126. if (!test_bit(PACKET_WRITABLE, &pd->flags)) {
  2127. printk(DRIVER_NAME": WRITE for ro device %s (%llu)\n",
  2128. pd->name, (unsigned long long)bio->bi_sector);
  2129. goto end_io;
  2130. }
  2131. if (!bio->bi_size || (bio->bi_size % CD_FRAMESIZE)) {
  2132. printk(DRIVER_NAME": wrong bio size\n");
  2133. goto end_io;
  2134. }
  2135. blk_queue_bounce(q, &bio);
  2136. zone = ZONE(bio->bi_sector, pd);
  2137. VPRINTK("pkt_make_request: start = %6llx stop = %6llx\n",
  2138. (unsigned long long)bio->bi_sector,
  2139. (unsigned long long)(bio->bi_sector + bio_sectors(bio)));
  2140. /* Check if we have to split the bio */
  2141. {
  2142. struct bio_pair *bp;
  2143. sector_t last_zone;
  2144. int first_sectors;
  2145. last_zone = ZONE(bio->bi_sector + bio_sectors(bio) - 1, pd);
  2146. if (last_zone != zone) {
  2147. BUG_ON(last_zone != zone + pd->settings.size);
  2148. first_sectors = last_zone - bio->bi_sector;
  2149. bp = bio_split(bio, first_sectors);
  2150. BUG_ON(!bp);
  2151. pkt_make_request(q, &bp->bio1);
  2152. pkt_make_request(q, &bp->bio2);
  2153. bio_pair_release(bp);
  2154. return 0;
  2155. }
  2156. }
  2157. /*
  2158. * If we find a matching packet in state WAITING or READ_WAIT, we can
  2159. * just append this bio to that packet.
  2160. */
  2161. spin_lock(&pd->cdrw.active_list_lock);
  2162. blocked_bio = 0;
  2163. list_for_each_entry(pkt, &pd->cdrw.pkt_active_list, list) {
  2164. if (pkt->sector == zone) {
  2165. spin_lock(&pkt->lock);
  2166. if ((pkt->state == PACKET_WAITING_STATE) ||
  2167. (pkt->state == PACKET_READ_WAIT_STATE)) {
  2168. bio_list_add(&pkt->orig_bios, bio);
  2169. pkt->write_size += bio->bi_size / CD_FRAMESIZE;
  2170. if ((pkt->write_size >= pkt->frames) &&
  2171. (pkt->state == PACKET_WAITING_STATE)) {
  2172. atomic_inc(&pkt->run_sm);
  2173. wake_up(&pd->wqueue);
  2174. }
  2175. spin_unlock(&pkt->lock);
  2176. spin_unlock(&pd->cdrw.active_list_lock);
  2177. return 0;
  2178. } else {
  2179. blocked_bio = 1;
  2180. }
  2181. spin_unlock(&pkt->lock);
  2182. }
  2183. }
  2184. spin_unlock(&pd->cdrw.active_list_lock);
  2185. /*
  2186. * Test if there is enough room left in the bio work queue
  2187. * (queue size >= congestion on mark).
  2188. * If not, wait till the work queue size is below the congestion off mark.
  2189. */
  2190. spin_lock(&pd->lock);
  2191. if (pd->write_congestion_on > 0
  2192. && pd->bio_queue_size >= pd->write_congestion_on) {
  2193. set_bdi_congested(&q->backing_dev_info, BLK_RW_ASYNC);
  2194. do {
  2195. spin_unlock(&pd->lock);
  2196. congestion_wait(BLK_RW_ASYNC, HZ);
  2197. spin_lock(&pd->lock);
  2198. } while(pd->bio_queue_size > pd->write_congestion_off);
  2199. }
  2200. spin_unlock(&pd->lock);
  2201. /*
  2202. * No matching packet found. Store the bio in the work queue.
  2203. */
  2204. node = mempool_alloc(pd->rb_pool, GFP_NOIO);
  2205. node->bio = bio;
  2206. spin_lock(&pd->lock);
  2207. BUG_ON(pd->bio_queue_size < 0);
  2208. was_empty = (pd->bio_queue_size == 0);
  2209. pkt_rbtree_insert(pd, node);
  2210. spin_unlock(&pd->lock);
  2211. /*
  2212. * Wake up the worker thread.
  2213. */
  2214. atomic_set(&pd->scan_queue, 1);
  2215. if (was_empty) {
  2216. /* This wake_up is required for correct operation */
  2217. wake_up(&pd->wqueue);
  2218. } else if (!list_empty(&pd->cdrw.pkt_free_list) && !blocked_bio) {
  2219. /*
  2220. * This wake up is not required for correct operation,
  2221. * but improves performance in some cases.
  2222. */
  2223. wake_up(&pd->wqueue);
  2224. }
  2225. return 0;
  2226. end_io:
  2227. bio_io_error(bio);
  2228. return 0;
  2229. }
  2230. static int pkt_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
  2231. struct bio_vec *bvec)
  2232. {
  2233. struct pktcdvd_device *pd = q->queuedata;
  2234. sector_t zone = ZONE(bmd->bi_sector, pd);
  2235. int used = ((bmd->bi_sector - zone) << 9) + bmd->bi_size;
  2236. int remaining = (pd->settings.size << 9) - used;
  2237. int remaining2;
  2238. /*
  2239. * A bio <= PAGE_SIZE must be allowed. If it crosses a packet
  2240. * boundary, pkt_make_request() will split the bio.
  2241. */
  2242. remaining2 = PAGE_SIZE - bmd->bi_size;
  2243. remaining = max(remaining, remaining2);
  2244. BUG_ON(remaining < 0);
  2245. return remaining;
  2246. }
  2247. static void pkt_init_queue(struct pktcdvd_device *pd)
  2248. {
  2249. struct request_queue *q = pd->disk->queue;
  2250. blk_queue_make_request(q, pkt_make_request);
  2251. blk_queue_logical_block_size(q, CD_FRAMESIZE);
  2252. blk_queue_max_sectors(q, PACKET_MAX_SECTORS);
  2253. blk_queue_merge_bvec(q, pkt_merge_bvec);
  2254. q->queuedata = pd;
  2255. }
  2256. static int pkt_seq_show(struct seq_file *m, void *p)
  2257. {
  2258. struct pktcdvd_device *pd = m->private;
  2259. char *msg;
  2260. char bdev_buf[BDEVNAME_SIZE];
  2261. int states[PACKET_NUM_STATES];
  2262. seq_printf(m, "Writer %s mapped to %s:\n", pd->name,
  2263. bdevname(pd->bdev, bdev_buf));
  2264. seq_printf(m, "\nSettings:\n");
  2265. seq_printf(m, "\tpacket size:\t\t%dkB\n", pd->settings.size / 2);
  2266. if (pd->settings.write_type == 0)
  2267. msg = "Packet";
  2268. else
  2269. msg = "Unknown";
  2270. seq_printf(m, "\twrite type:\t\t%s\n", msg);
  2271. seq_printf(m, "\tpacket type:\t\t%s\n", pd->settings.fp ? "Fixed" : "Variable");
  2272. seq_printf(m, "\tlink loss:\t\t%d\n", pd->settings.link_loss);
  2273. seq_printf(m, "\ttrack mode:\t\t%d\n", pd->settings.track_mode);
  2274. if (pd->settings.block_mode == PACKET_BLOCK_MODE1)
  2275. msg = "Mode 1";
  2276. else if (pd->settings.block_mode == PACKET_BLOCK_MODE2)
  2277. msg = "Mode 2";
  2278. else
  2279. msg = "Unknown";
  2280. seq_printf(m, "\tblock mode:\t\t%s\n", msg);
  2281. seq_printf(m, "\nStatistics:\n");
  2282. seq_printf(m, "\tpackets started:\t%lu\n", pd->stats.pkt_started);
  2283. seq_printf(m, "\tpackets ended:\t\t%lu\n", pd->stats.pkt_ended);
  2284. seq_printf(m, "\twritten:\t\t%lukB\n", pd->stats.secs_w >> 1);
  2285. seq_printf(m, "\tread gather:\t\t%lukB\n", pd->stats.secs_rg >> 1);
  2286. seq_printf(m, "\tread:\t\t\t%lukB\n", pd->stats.secs_r >> 1);
  2287. seq_printf(m, "\nMisc:\n");
  2288. seq_printf(m, "\treference count:\t%d\n", pd->refcnt);
  2289. seq_printf(m, "\tflags:\t\t\t0x%lx\n", pd->flags);
  2290. seq_printf(m, "\tread speed:\t\t%ukB/s\n", pd->read_speed);
  2291. seq_printf(m, "\twrite speed:\t\t%ukB/s\n", pd->write_speed);
  2292. seq_printf(m, "\tstart offset:\t\t%lu\n", pd->offset);
  2293. seq_printf(m, "\tmode page offset:\t%u\n", pd->mode_offset);
  2294. seq_printf(m, "\nQueue state:\n");
  2295. seq_printf(m, "\tbios queued:\t\t%d\n", pd->bio_queue_size);
  2296. seq_printf(m, "\tbios pending:\t\t%d\n", atomic_read(&pd->cdrw.pending_bios));
  2297. seq_printf(m, "\tcurrent sector:\t\t0x%llx\n", (unsigned long long)pd->current_sector);
  2298. pkt_count_states(pd, states);
  2299. seq_printf(m, "\tstate:\t\t\ti:%d ow:%d rw:%d ww:%d rec:%d fin:%d\n",
  2300. states[0], states[1], states[2], states[3], states[4], states[5]);
  2301. seq_printf(m, "\twrite congestion marks:\toff=%d on=%d\n",
  2302. pd->write_congestion_off,
  2303. pd->write_congestion_on);
  2304. return 0;
  2305. }
  2306. static int pkt_seq_open(struct inode *inode, struct file *file)
  2307. {
  2308. return single_open(file, pkt_seq_show, PDE(inode)->data);
  2309. }
  2310. static const struct file_operations pkt_proc_fops = {
  2311. .open = pkt_seq_open,
  2312. .read = seq_read,
  2313. .llseek = seq_lseek,
  2314. .release = single_release
  2315. };
  2316. static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
  2317. {
  2318. int i;
  2319. int ret = 0;
  2320. char b[BDEVNAME_SIZE];
  2321. struct block_device *bdev;
  2322. if (pd->pkt_dev == dev) {
  2323. printk(DRIVER_NAME": Recursive setup not allowed\n");
  2324. return -EBUSY;
  2325. }
  2326. for (i = 0; i < MAX_WRITERS; i++) {
  2327. struct pktcdvd_device *pd2 = pkt_devs[i];
  2328. if (!pd2)
  2329. continue;
  2330. if (pd2->bdev->bd_dev == dev) {
  2331. printk(DRIVER_NAME": %s already setup\n", bdevname(pd2->bdev, b));
  2332. return -EBUSY;
  2333. }
  2334. if (pd2->pkt_dev == dev) {
  2335. printk(DRIVER_NAME": Can't chain pktcdvd devices\n");
  2336. return -EBUSY;
  2337. }
  2338. }
  2339. bdev = bdget(dev);
  2340. if (!bdev)
  2341. return -ENOMEM;
  2342. ret = blkdev_get(bdev, FMODE_READ | FMODE_NDELAY);
  2343. if (ret)
  2344. return ret;
  2345. /* This is safe, since we have a reference from open(). */
  2346. __module_get(THIS_MODULE);
  2347. pd->bdev = bdev;
  2348. set_blocksize(bdev, CD_FRAMESIZE);
  2349. pkt_init_queue(pd);
  2350. atomic_set(&pd->cdrw.pending_bios, 0);
  2351. pd->cdrw.thread = kthread_run(kcdrwd, pd, "%s", pd->name);
  2352. if (IS_ERR(pd->cdrw.thread)) {
  2353. printk(DRIVER_NAME": can't start kernel thread\n");
  2354. ret = -ENOMEM;
  2355. goto out_mem;
  2356. }
  2357. proc_create_data(pd->name, 0, pkt_proc, &pkt_proc_fops, pd);
  2358. DPRINTK(DRIVER_NAME": writer %s mapped to %s\n", pd->name, bdevname(bdev, b));
  2359. return 0;
  2360. out_mem:
  2361. blkdev_put(bdev, FMODE_READ | FMODE_NDELAY);
  2362. /* This is safe: open() is still holding a reference. */
  2363. module_put(THIS_MODULE);
  2364. return ret;
  2365. }
  2366. static int pkt_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
  2367. {
  2368. struct pktcdvd_device *pd = bdev->bd_disk->private_data;
  2369. VPRINTK("pkt_ioctl: cmd %x, dev %d:%d\n", cmd,
  2370. MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev));
  2371. switch (cmd) {
  2372. case CDROMEJECT:
  2373. /*
  2374. * The door gets locked when the device is opened, so we
  2375. * have to unlock it or else the eject command fails.
  2376. */
  2377. if (pd->refcnt == 1)
  2378. pkt_lock_door(pd, 0);
  2379. /* fallthru */
  2380. /*
  2381. * forward selected CDROM ioctls to CD-ROM, for UDF
  2382. */
  2383. case CDROMMULTISESSION:
  2384. case CDROMREADTOCENTRY:
  2385. case CDROM_LAST_WRITTEN:
  2386. case CDROM_SEND_PACKET:
  2387. case SCSI_IOCTL_SEND_COMMAND:
  2388. return __blkdev_driver_ioctl(pd->bdev, mode, cmd, arg);
  2389. default:
  2390. VPRINTK(DRIVER_NAME": Unknown ioctl for %s (%x)\n", pd->name, cmd);
  2391. return -ENOTTY;
  2392. }
  2393. return 0;
  2394. }
  2395. static int pkt_media_changed(struct gendisk *disk)
  2396. {
  2397. struct pktcdvd_device *pd = disk->private_data;
  2398. struct gendisk *attached_disk;
  2399. if (!pd)
  2400. return 0;
  2401. if (!pd->bdev)
  2402. return 0;
  2403. attached_disk = pd->bdev->bd_disk;
  2404. if (!attached_disk)
  2405. return 0;
  2406. return attached_disk->fops->media_changed(attached_disk);
  2407. }
  2408. static const struct block_device_operations pktcdvd_ops = {
  2409. .owner = THIS_MODULE,
  2410. .open = pkt_open,
  2411. .release = pkt_close,
  2412. .locked_ioctl = pkt_ioctl,
  2413. .media_changed = pkt_media_changed,
  2414. };
  2415. static char *pktcdvd_devnode(struct gendisk *gd, mode_t *mode)
  2416. {
  2417. return kasprintf(GFP_KERNEL, "pktcdvd/%s", gd->disk_name);
  2418. }
  2419. /*
  2420. * Set up mapping from pktcdvd device to CD-ROM device.
  2421. */
  2422. static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev)
  2423. {
  2424. int idx;
  2425. int ret = -ENOMEM;
  2426. struct pktcdvd_device *pd;
  2427. struct gendisk *disk;
  2428. mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
  2429. for (idx = 0; idx < MAX_WRITERS; idx++)
  2430. if (!pkt_devs[idx])
  2431. break;
  2432. if (idx == MAX_WRITERS) {
  2433. printk(DRIVER_NAME": max %d writers supported\n", MAX_WRITERS);
  2434. ret = -EBUSY;
  2435. goto out_mutex;
  2436. }
  2437. pd = kzalloc(sizeof(struct pktcdvd_device), GFP_KERNEL);
  2438. if (!pd)
  2439. goto out_mutex;
  2440. pd->rb_pool = mempool_create_kmalloc_pool(PKT_RB_POOL_SIZE,
  2441. sizeof(struct pkt_rb_node));
  2442. if (!pd->rb_pool)
  2443. goto out_mem;
  2444. INIT_LIST_HEAD(&pd->cdrw.pkt_free_list);
  2445. INIT_LIST_HEAD(&pd->cdrw.pkt_active_list);
  2446. spin_lock_init(&pd->cdrw.active_list_lock);
  2447. spin_lock_init(&pd->lock);
  2448. spin_lock_init(&pd->iosched.lock);
  2449. bio_list_init(&pd->iosched.read_queue);
  2450. bio_list_init(&pd->iosched.write_queue);
  2451. sprintf(pd->name, DRIVER_NAME"%d", idx);
  2452. init_waitqueue_head(&pd->wqueue);
  2453. pd->bio_queue = RB_ROOT;
  2454. pd->write_congestion_on = write_congestion_on;
  2455. pd->write_congestion_off = write_congestion_off;
  2456. disk = alloc_disk(1);
  2457. if (!disk)
  2458. goto out_mem;
  2459. pd->disk = disk;
  2460. disk->major = pktdev_major;
  2461. disk->first_minor = idx;
  2462. disk->fops = &pktcdvd_ops;
  2463. disk->flags = GENHD_FL_REMOVABLE;
  2464. strcpy(disk->disk_name, pd->name);
  2465. disk->devnode = pktcdvd_devnode;
  2466. disk->private_data = pd;
  2467. disk->queue = blk_alloc_queue(GFP_KERNEL);
  2468. if (!disk->queue)
  2469. goto out_mem2;
  2470. pd->pkt_dev = MKDEV(pktdev_major, idx);
  2471. ret = pkt_new_dev(pd, dev);
  2472. if (ret)
  2473. goto out_new_dev;
  2474. add_disk(disk);
  2475. pkt_sysfs_dev_new(pd);
  2476. pkt_debugfs_dev_new(pd);
  2477. pkt_devs[idx] = pd;
  2478. if (pkt_dev)
  2479. *pkt_dev = pd->pkt_dev;
  2480. mutex_unlock(&ctl_mutex);
  2481. return 0;
  2482. out_new_dev:
  2483. blk_cleanup_queue(disk->queue);
  2484. out_mem2:
  2485. put_disk(disk);
  2486. out_mem:
  2487. if (pd->rb_pool)
  2488. mempool_destroy(pd->rb_pool);
  2489. kfree(pd);
  2490. out_mutex:
  2491. mutex_unlock(&ctl_mutex);
  2492. printk(DRIVER_NAME": setup of pktcdvd device failed\n");
  2493. return ret;
  2494. }
  2495. /*
  2496. * Tear down mapping from pktcdvd device to CD-ROM device.
  2497. */
  2498. static int pkt_remove_dev(dev_t pkt_dev)
  2499. {
  2500. struct pktcdvd_device *pd;
  2501. int idx;
  2502. int ret = 0;
  2503. mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
  2504. for (idx = 0; idx < MAX_WRITERS; idx++) {
  2505. pd = pkt_devs[idx];
  2506. if (pd && (pd->pkt_dev == pkt_dev))
  2507. break;
  2508. }
  2509. if (idx == MAX_WRITERS) {
  2510. DPRINTK(DRIVER_NAME": dev not setup\n");
  2511. ret = -ENXIO;
  2512. goto out;
  2513. }
  2514. if (pd->refcnt > 0) {
  2515. ret = -EBUSY;
  2516. goto out;
  2517. }
  2518. if (!IS_ERR(pd->cdrw.thread))
  2519. kthread_stop(pd->cdrw.thread);
  2520. pkt_devs[idx] = NULL;
  2521. pkt_debugfs_dev_remove(pd);
  2522. pkt_sysfs_dev_remove(pd);
  2523. blkdev_put(pd->bdev, FMODE_READ | FMODE_NDELAY);
  2524. remove_proc_entry(pd->name, pkt_proc);
  2525. DPRINTK(DRIVER_NAME": writer %s unmapped\n", pd->name);
  2526. del_gendisk(pd->disk);
  2527. blk_cleanup_queue(pd->disk->queue);
  2528. put_disk(pd->disk);
  2529. mempool_destroy(pd->rb_pool);
  2530. kfree(pd);
  2531. /* This is safe: open() is still holding a reference. */
  2532. module_put(THIS_MODULE);
  2533. out:
  2534. mutex_unlock(&ctl_mutex);
  2535. return ret;
  2536. }
  2537. static void pkt_get_status(struct pkt_ctrl_command *ctrl_cmd)
  2538. {
  2539. struct pktcdvd_device *pd;
  2540. mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
  2541. pd = pkt_find_dev_from_minor(ctrl_cmd->dev_index);
  2542. if (pd) {
  2543. ctrl_cmd->dev = new_encode_dev(pd->bdev->bd_dev);
  2544. ctrl_cmd->pkt_dev = new_encode_dev(pd->pkt_dev);
  2545. } else {
  2546. ctrl_cmd->dev = 0;
  2547. ctrl_cmd->pkt_dev = 0;
  2548. }
  2549. ctrl_cmd->num_devices = MAX_WRITERS;
  2550. mutex_unlock(&ctl_mutex);
  2551. }
  2552. static int pkt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  2553. {
  2554. void __user *argp = (void __user *)arg;
  2555. struct pkt_ctrl_command ctrl_cmd;
  2556. int ret = 0;
  2557. dev_t pkt_dev = 0;
  2558. if (cmd != PACKET_CTRL_CMD)
  2559. return -ENOTTY;
  2560. if (copy_from_user(&ctrl_cmd, argp, sizeof(struct pkt_ctrl_command)))
  2561. return -EFAULT;
  2562. switch (ctrl_cmd.command) {
  2563. case PKT_CTRL_CMD_SETUP:
  2564. if (!capable(CAP_SYS_ADMIN))
  2565. return -EPERM;
  2566. ret = pkt_setup_dev(new_decode_dev(ctrl_cmd.dev), &pkt_dev);
  2567. ctrl_cmd.pkt_dev = new_encode_dev(pkt_dev);
  2568. break;
  2569. case PKT_CTRL_CMD_TEARDOWN:
  2570. if (!capable(CAP_SYS_ADMIN))
  2571. return -EPERM;
  2572. ret = pkt_remove_dev(new_decode_dev(ctrl_cmd.pkt_dev));
  2573. break;
  2574. case PKT_CTRL_CMD_STATUS:
  2575. pkt_get_status(&ctrl_cmd);
  2576. break;
  2577. default:
  2578. return -ENOTTY;
  2579. }
  2580. if (copy_to_user(argp, &ctrl_cmd, sizeof(struct pkt_ctrl_command)))
  2581. return -EFAULT;
  2582. return ret;
  2583. }
  2584. static const struct file_operations pkt_ctl_fops = {
  2585. .ioctl = pkt_ctl_ioctl,
  2586. .owner = THIS_MODULE,
  2587. };
  2588. static struct miscdevice pkt_misc = {
  2589. .minor = MISC_DYNAMIC_MINOR,
  2590. .name = DRIVER_NAME,
  2591. .nodename = "pktcdvd/control",
  2592. .fops = &pkt_ctl_fops
  2593. };
  2594. static int __init pkt_init(void)
  2595. {
  2596. int ret;
  2597. mutex_init(&ctl_mutex);
  2598. psd_pool = mempool_create_kmalloc_pool(PSD_POOL_SIZE,
  2599. sizeof(struct packet_stacked_data));
  2600. if (!psd_pool)
  2601. return -ENOMEM;
  2602. ret = register_blkdev(pktdev_major, DRIVER_NAME);
  2603. if (ret < 0) {
  2604. printk(DRIVER_NAME": Unable to register block device\n");
  2605. goto out2;
  2606. }
  2607. if (!pktdev_major)
  2608. pktdev_major = ret;
  2609. ret = pkt_sysfs_init();
  2610. if (ret)
  2611. goto out;
  2612. pkt_debugfs_init();
  2613. ret = misc_register(&pkt_misc);
  2614. if (ret) {
  2615. printk(DRIVER_NAME": Unable to register misc device\n");
  2616. goto out_misc;
  2617. }
  2618. pkt_proc = proc_mkdir("driver/"DRIVER_NAME, NULL);
  2619. return 0;
  2620. out_misc:
  2621. pkt_debugfs_cleanup();
  2622. pkt_sysfs_cleanup();
  2623. out:
  2624. unregister_blkdev(pktdev_major, DRIVER_NAME);
  2625. out2:
  2626. mempool_destroy(psd_pool);
  2627. return ret;
  2628. }
  2629. static void __exit pkt_exit(void)
  2630. {
  2631. remove_proc_entry("driver/"DRIVER_NAME, NULL);
  2632. misc_deregister(&pkt_misc);
  2633. pkt_debugfs_cleanup();
  2634. pkt_sysfs_cleanup();
  2635. unregister_blkdev(pktdev_major, DRIVER_NAME);
  2636. mempool_destroy(psd_pool);
  2637. }
  2638. MODULE_DESCRIPTION("Packet writing layer for CD/DVD drives");
  2639. MODULE_AUTHOR("Jens Axboe <axboe@suse.de>");
  2640. MODULE_LICENSE("GPL");
  2641. module_init(pkt_init);
  2642. module_exit(pkt_exit);