build.c 39 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376
  1. /*
  2. * Copyright (c) International Business Machines Corp., 2006
  3. * Copyright (c) Nokia Corporation, 2007
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; either version 2 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
  13. * the GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program; if not, write to the Free Software
  17. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18. *
  19. * Author: Artem Bityutskiy (Битюцкий Артём),
  20. * Frank Haverkamp
  21. */
  22. /*
  23. * This file includes UBI initialization and building of UBI devices.
  24. *
  25. * When UBI is initialized, it attaches all the MTD devices specified as the
  26. * module load parameters or the kernel boot parameters. If MTD devices were
  27. * specified, UBI does not attach any MTD device, but it is possible to do
  28. * later using the "UBI control device".
  29. *
  30. * At the moment we only attach UBI devices by scanning, which will become a
  31. * bottleneck when flashes reach certain large size. Then one may improve UBI
  32. * and add other methods, although it does not seem to be easy to do.
  33. */
  34. #include <linux/err.h>
  35. #include <linux/module.h>
  36. #include <linux/moduleparam.h>
  37. #include <linux/stringify.h>
  38. #include <linux/namei.h>
  39. #include <linux/stat.h>
  40. #include <linux/miscdevice.h>
  41. #include <linux/log2.h>
  42. #include <linux/kthread.h>
  43. #include <linux/kernel.h>
  44. #include <linux/slab.h>
  45. #include "ubi.h"
  46. /* Maximum length of the 'mtd=' parameter */
  47. #define MTD_PARAM_LEN_MAX 64
  48. /**
  49. * struct mtd_dev_param - MTD device parameter description data structure.
  50. * @name: MTD character device node path, MTD device name, or MTD device number
  51. * string
  52. * @vid_hdr_offs: VID header offset
  53. */
  54. struct mtd_dev_param {
  55. char name[MTD_PARAM_LEN_MAX];
  56. int vid_hdr_offs;
  57. };
  58. /* Numbers of elements set in the @mtd_dev_param array */
  59. static int __initdata mtd_devs;
  60. /* MTD devices specification parameters */
  61. static struct mtd_dev_param __initdata mtd_dev_param[UBI_MAX_DEVICES];
  62. /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
  63. struct class *ubi_class;
  64. /* Slab cache for wear-leveling entries */
  65. struct kmem_cache *ubi_wl_entry_slab;
  66. /* UBI control character device */
  67. static struct miscdevice ubi_ctrl_cdev = {
  68. .minor = MISC_DYNAMIC_MINOR,
  69. .name = "ubi_ctrl",
  70. .fops = &ubi_ctrl_cdev_operations,
  71. };
  72. /* All UBI devices in system */
  73. static struct ubi_device *ubi_devices[UBI_MAX_DEVICES];
  74. /* Serializes UBI devices creations and removals */
  75. DEFINE_MUTEX(ubi_devices_mutex);
  76. /* Protects @ubi_devices and @ubi->ref_count */
  77. static DEFINE_SPINLOCK(ubi_devices_lock);
  78. /* "Show" method for files in '/<sysfs>/class/ubi/' */
  79. static ssize_t ubi_version_show(struct class *class, struct class_attribute *attr,
  80. char *buf)
  81. {
  82. return sprintf(buf, "%d\n", UBI_VERSION);
  83. }
  84. /* UBI version attribute ('/<sysfs>/class/ubi/version') */
  85. static struct class_attribute ubi_version =
  86. __ATTR(version, S_IRUGO, ubi_version_show, NULL);
  87. static ssize_t dev_attribute_show(struct device *dev,
  88. struct device_attribute *attr, char *buf);
  89. /* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */
  90. static struct device_attribute dev_eraseblock_size =
  91. __ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL);
  92. static struct device_attribute dev_avail_eraseblocks =
  93. __ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
  94. static struct device_attribute dev_total_eraseblocks =
  95. __ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
  96. static struct device_attribute dev_volumes_count =
  97. __ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL);
  98. static struct device_attribute dev_max_ec =
  99. __ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL);
  100. static struct device_attribute dev_reserved_for_bad =
  101. __ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL);
  102. static struct device_attribute dev_bad_peb_count =
  103. __ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL);
  104. static struct device_attribute dev_max_vol_count =
  105. __ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL);
  106. static struct device_attribute dev_min_io_size =
  107. __ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL);
  108. static struct device_attribute dev_bgt_enabled =
  109. __ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL);
  110. static struct device_attribute dev_mtd_num =
  111. __ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL);
  112. /**
  113. * ubi_volume_notify - send a volume change notification.
  114. * @ubi: UBI device description object
  115. * @vol: volume description object of the changed volume
  116. * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
  117. *
  118. * This is a helper function which notifies all subscribers about a volume
  119. * change event (creation, removal, re-sizing, re-naming, updating). Returns
  120. * zero in case of success and a negative error code in case of failure.
  121. */
  122. int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol, int ntype)
  123. {
  124. struct ubi_notification nt;
  125. ubi_do_get_device_info(ubi, &nt.di);
  126. ubi_do_get_volume_info(ubi, vol, &nt.vi);
  127. return blocking_notifier_call_chain(&ubi_notifiers, ntype, &nt);
  128. }
  129. /**
  130. * ubi_notify_all - send a notification to all volumes.
  131. * @ubi: UBI device description object
  132. * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc)
  133. * @nb: the notifier to call
  134. *
  135. * This function walks all volumes of UBI device @ubi and sends the @ntype
  136. * notification for each volume. If @nb is %NULL, then all registered notifiers
  137. * are called, otherwise only the @nb notifier is called. Returns the number of
  138. * sent notifications.
  139. */
  140. int ubi_notify_all(struct ubi_device *ubi, int ntype, struct notifier_block *nb)
  141. {
  142. struct ubi_notification nt;
  143. int i, count = 0;
  144. ubi_do_get_device_info(ubi, &nt.di);
  145. mutex_lock(&ubi->device_mutex);
  146. for (i = 0; i < ubi->vtbl_slots; i++) {
  147. /*
  148. * Since the @ubi->device is locked, and we are not going to
  149. * change @ubi->volumes, we do not have to lock
  150. * @ubi->volumes_lock.
  151. */
  152. if (!ubi->volumes[i])
  153. continue;
  154. ubi_do_get_volume_info(ubi, ubi->volumes[i], &nt.vi);
  155. if (nb)
  156. nb->notifier_call(nb, ntype, &nt);
  157. else
  158. blocking_notifier_call_chain(&ubi_notifiers, ntype,
  159. &nt);
  160. count += 1;
  161. }
  162. mutex_unlock(&ubi->device_mutex);
  163. return count;
  164. }
  165. /**
  166. * ubi_enumerate_volumes - send "add" notification for all existing volumes.
  167. * @nb: the notifier to call
  168. *
  169. * This function walks all UBI devices and volumes and sends the
  170. * %UBI_VOLUME_ADDED notification for each volume. If @nb is %NULL, then all
  171. * registered notifiers are called, otherwise only the @nb notifier is called.
  172. * Returns the number of sent notifications.
  173. */
  174. int ubi_enumerate_volumes(struct notifier_block *nb)
  175. {
  176. int i, count = 0;
  177. /*
  178. * Since the @ubi_devices_mutex is locked, and we are not going to
  179. * change @ubi_devices, we do not have to lock @ubi_devices_lock.
  180. */
  181. for (i = 0; i < UBI_MAX_DEVICES; i++) {
  182. struct ubi_device *ubi = ubi_devices[i];
  183. if (!ubi)
  184. continue;
  185. count += ubi_notify_all(ubi, UBI_VOLUME_ADDED, nb);
  186. }
  187. return count;
  188. }
  189. /**
  190. * ubi_get_device - get UBI device.
  191. * @ubi_num: UBI device number
  192. *
  193. * This function returns UBI device description object for UBI device number
  194. * @ubi_num, or %NULL if the device does not exist. This function increases the
  195. * device reference count to prevent removal of the device. In other words, the
  196. * device cannot be removed if its reference count is not zero.
  197. */
  198. struct ubi_device *ubi_get_device(int ubi_num)
  199. {
  200. struct ubi_device *ubi;
  201. spin_lock(&ubi_devices_lock);
  202. ubi = ubi_devices[ubi_num];
  203. if (ubi) {
  204. ubi_assert(ubi->ref_count >= 0);
  205. ubi->ref_count += 1;
  206. get_device(&ubi->dev);
  207. }
  208. spin_unlock(&ubi_devices_lock);
  209. return ubi;
  210. }
  211. /**
  212. * ubi_put_device - drop an UBI device reference.
  213. * @ubi: UBI device description object
  214. */
  215. void ubi_put_device(struct ubi_device *ubi)
  216. {
  217. spin_lock(&ubi_devices_lock);
  218. ubi->ref_count -= 1;
  219. put_device(&ubi->dev);
  220. spin_unlock(&ubi_devices_lock);
  221. }
  222. /**
  223. * ubi_get_by_major - get UBI device by character device major number.
  224. * @major: major number
  225. *
  226. * This function is similar to 'ubi_get_device()', but it searches the device
  227. * by its major number.
  228. */
  229. struct ubi_device *ubi_get_by_major(int major)
  230. {
  231. int i;
  232. struct ubi_device *ubi;
  233. spin_lock(&ubi_devices_lock);
  234. for (i = 0; i < UBI_MAX_DEVICES; i++) {
  235. ubi = ubi_devices[i];
  236. if (ubi && MAJOR(ubi->cdev.dev) == major) {
  237. ubi_assert(ubi->ref_count >= 0);
  238. ubi->ref_count += 1;
  239. get_device(&ubi->dev);
  240. spin_unlock(&ubi_devices_lock);
  241. return ubi;
  242. }
  243. }
  244. spin_unlock(&ubi_devices_lock);
  245. return NULL;
  246. }
  247. /**
  248. * ubi_major2num - get UBI device number by character device major number.
  249. * @major: major number
  250. *
  251. * This function searches UBI device number object by its major number. If UBI
  252. * device was not found, this function returns -ENODEV, otherwise the UBI device
  253. * number is returned.
  254. */
  255. int ubi_major2num(int major)
  256. {
  257. int i, ubi_num = -ENODEV;
  258. spin_lock(&ubi_devices_lock);
  259. for (i = 0; i < UBI_MAX_DEVICES; i++) {
  260. struct ubi_device *ubi = ubi_devices[i];
  261. if (ubi && MAJOR(ubi->cdev.dev) == major) {
  262. ubi_num = ubi->ubi_num;
  263. break;
  264. }
  265. }
  266. spin_unlock(&ubi_devices_lock);
  267. return ubi_num;
  268. }
  269. /* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */
  270. static ssize_t dev_attribute_show(struct device *dev,
  271. struct device_attribute *attr, char *buf)
  272. {
  273. ssize_t ret;
  274. struct ubi_device *ubi;
  275. /*
  276. * The below code looks weird, but it actually makes sense. We get the
  277. * UBI device reference from the contained 'struct ubi_device'. But it
  278. * is unclear if the device was removed or not yet. Indeed, if the
  279. * device was removed before we increased its reference count,
  280. * 'ubi_get_device()' will return -ENODEV and we fail.
  281. *
  282. * Remember, 'struct ubi_device' is freed in the release function, so
  283. * we still can use 'ubi->ubi_num'.
  284. */
  285. ubi = container_of(dev, struct ubi_device, dev);
  286. ubi = ubi_get_device(ubi->ubi_num);
  287. if (!ubi)
  288. return -ENODEV;
  289. if (attr == &dev_eraseblock_size)
  290. ret = sprintf(buf, "%d\n", ubi->leb_size);
  291. else if (attr == &dev_avail_eraseblocks)
  292. ret = sprintf(buf, "%d\n", ubi->avail_pebs);
  293. else if (attr == &dev_total_eraseblocks)
  294. ret = sprintf(buf, "%d\n", ubi->good_peb_count);
  295. else if (attr == &dev_volumes_count)
  296. ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT);
  297. else if (attr == &dev_max_ec)
  298. ret = sprintf(buf, "%d\n", ubi->max_ec);
  299. else if (attr == &dev_reserved_for_bad)
  300. ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs);
  301. else if (attr == &dev_bad_peb_count)
  302. ret = sprintf(buf, "%d\n", ubi->bad_peb_count);
  303. else if (attr == &dev_max_vol_count)
  304. ret = sprintf(buf, "%d\n", ubi->vtbl_slots);
  305. else if (attr == &dev_min_io_size)
  306. ret = sprintf(buf, "%d\n", ubi->min_io_size);
  307. else if (attr == &dev_bgt_enabled)
  308. ret = sprintf(buf, "%d\n", ubi->thread_enabled);
  309. else if (attr == &dev_mtd_num)
  310. ret = sprintf(buf, "%d\n", ubi->mtd->index);
  311. else
  312. ret = -EINVAL;
  313. ubi_put_device(ubi);
  314. return ret;
  315. }
  316. static void dev_release(struct device *dev)
  317. {
  318. struct ubi_device *ubi = container_of(dev, struct ubi_device, dev);
  319. kfree(ubi);
  320. }
  321. /**
  322. * ubi_sysfs_init - initialize sysfs for an UBI device.
  323. * @ubi: UBI device description object
  324. * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
  325. * taken
  326. *
  327. * This function returns zero in case of success and a negative error code in
  328. * case of failure.
  329. */
  330. static int ubi_sysfs_init(struct ubi_device *ubi, int *ref)
  331. {
  332. int err;
  333. ubi->dev.release = dev_release;
  334. ubi->dev.devt = ubi->cdev.dev;
  335. ubi->dev.class = ubi_class;
  336. dev_set_name(&ubi->dev, UBI_NAME_STR"%d", ubi->ubi_num);
  337. err = device_register(&ubi->dev);
  338. if (err)
  339. return err;
  340. *ref = 1;
  341. err = device_create_file(&ubi->dev, &dev_eraseblock_size);
  342. if (err)
  343. return err;
  344. err = device_create_file(&ubi->dev, &dev_avail_eraseblocks);
  345. if (err)
  346. return err;
  347. err = device_create_file(&ubi->dev, &dev_total_eraseblocks);
  348. if (err)
  349. return err;
  350. err = device_create_file(&ubi->dev, &dev_volumes_count);
  351. if (err)
  352. return err;
  353. err = device_create_file(&ubi->dev, &dev_max_ec);
  354. if (err)
  355. return err;
  356. err = device_create_file(&ubi->dev, &dev_reserved_for_bad);
  357. if (err)
  358. return err;
  359. err = device_create_file(&ubi->dev, &dev_bad_peb_count);
  360. if (err)
  361. return err;
  362. err = device_create_file(&ubi->dev, &dev_max_vol_count);
  363. if (err)
  364. return err;
  365. err = device_create_file(&ubi->dev, &dev_min_io_size);
  366. if (err)
  367. return err;
  368. err = device_create_file(&ubi->dev, &dev_bgt_enabled);
  369. if (err)
  370. return err;
  371. err = device_create_file(&ubi->dev, &dev_mtd_num);
  372. return err;
  373. }
  374. /**
  375. * ubi_sysfs_close - close sysfs for an UBI device.
  376. * @ubi: UBI device description object
  377. */
  378. static void ubi_sysfs_close(struct ubi_device *ubi)
  379. {
  380. device_remove_file(&ubi->dev, &dev_mtd_num);
  381. device_remove_file(&ubi->dev, &dev_bgt_enabled);
  382. device_remove_file(&ubi->dev, &dev_min_io_size);
  383. device_remove_file(&ubi->dev, &dev_max_vol_count);
  384. device_remove_file(&ubi->dev, &dev_bad_peb_count);
  385. device_remove_file(&ubi->dev, &dev_reserved_for_bad);
  386. device_remove_file(&ubi->dev, &dev_max_ec);
  387. device_remove_file(&ubi->dev, &dev_volumes_count);
  388. device_remove_file(&ubi->dev, &dev_total_eraseblocks);
  389. device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
  390. device_remove_file(&ubi->dev, &dev_eraseblock_size);
  391. device_unregister(&ubi->dev);
  392. }
  393. /**
  394. * kill_volumes - destroy all user volumes.
  395. * @ubi: UBI device description object
  396. */
  397. static void kill_volumes(struct ubi_device *ubi)
  398. {
  399. int i;
  400. for (i = 0; i < ubi->vtbl_slots; i++)
  401. if (ubi->volumes[i])
  402. ubi_free_volume(ubi, ubi->volumes[i]);
  403. }
  404. /**
  405. * uif_init - initialize user interfaces for an UBI device.
  406. * @ubi: UBI device description object
  407. * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
  408. * taken, otherwise set to %0
  409. *
  410. * This function initializes various user interfaces for an UBI device. If the
  411. * initialization fails at an early stage, this function frees all the
  412. * resources it allocated, returns an error, and @ref is set to %0. However,
  413. * if the initialization fails after the UBI device was registered in the
  414. * driver core subsystem, this function takes a reference to @ubi->dev, because
  415. * otherwise the release function ('dev_release()') would free whole @ubi
  416. * object. The @ref argument is set to %1 in this case. The caller has to put
  417. * this reference.
  418. *
  419. * This function returns zero in case of success and a negative error code in
  420. * case of failure.
  421. */
  422. static int uif_init(struct ubi_device *ubi, int *ref)
  423. {
  424. int i, err;
  425. dev_t dev;
  426. *ref = 0;
  427. sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
  428. /*
  429. * Major numbers for the UBI character devices are allocated
  430. * dynamically. Major numbers of volume character devices are
  431. * equivalent to ones of the corresponding UBI character device. Minor
  432. * numbers of UBI character devices are 0, while minor numbers of
  433. * volume character devices start from 1. Thus, we allocate one major
  434. * number and ubi->vtbl_slots + 1 minor numbers.
  435. */
  436. err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name);
  437. if (err) {
  438. ubi_err("cannot register UBI character devices");
  439. return err;
  440. }
  441. ubi_assert(MINOR(dev) == 0);
  442. cdev_init(&ubi->cdev, &ubi_cdev_operations);
  443. dbg_gen("%s major is %u", ubi->ubi_name, MAJOR(dev));
  444. ubi->cdev.owner = THIS_MODULE;
  445. err = cdev_add(&ubi->cdev, dev, 1);
  446. if (err) {
  447. ubi_err("cannot add character device");
  448. goto out_unreg;
  449. }
  450. err = ubi_sysfs_init(ubi, ref);
  451. if (err)
  452. goto out_sysfs;
  453. for (i = 0; i < ubi->vtbl_slots; i++)
  454. if (ubi->volumes[i]) {
  455. err = ubi_add_volume(ubi, ubi->volumes[i]);
  456. if (err) {
  457. ubi_err("cannot add volume %d", i);
  458. goto out_volumes;
  459. }
  460. }
  461. return 0;
  462. out_volumes:
  463. kill_volumes(ubi);
  464. out_sysfs:
  465. if (*ref)
  466. get_device(&ubi->dev);
  467. ubi_sysfs_close(ubi);
  468. cdev_del(&ubi->cdev);
  469. out_unreg:
  470. unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
  471. ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err);
  472. return err;
  473. }
  474. /**
  475. * uif_close - close user interfaces for an UBI device.
  476. * @ubi: UBI device description object
  477. *
  478. * Note, since this function un-registers UBI volume device objects (@vol->dev),
  479. * the memory allocated voe the volumes is freed as well (in the release
  480. * function).
  481. */
  482. static void uif_close(struct ubi_device *ubi)
  483. {
  484. kill_volumes(ubi);
  485. ubi_sysfs_close(ubi);
  486. cdev_del(&ubi->cdev);
  487. unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
  488. }
  489. /**
  490. * free_internal_volumes - free internal volumes.
  491. * @ubi: UBI device description object
  492. */
  493. static void free_internal_volumes(struct ubi_device *ubi)
  494. {
  495. int i;
  496. for (i = ubi->vtbl_slots;
  497. i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
  498. kfree(ubi->volumes[i]->eba_tbl);
  499. kfree(ubi->volumes[i]);
  500. }
  501. }
  502. /**
  503. * attach_by_scanning - attach an MTD device using scanning method.
  504. * @ubi: UBI device descriptor
  505. *
  506. * This function returns zero in case of success and a negative error code in
  507. * case of failure.
  508. *
  509. * Note, currently this is the only method to attach UBI devices. Hopefully in
  510. * the future we'll have more scalable attaching methods and avoid full media
  511. * scanning. But even in this case scanning will be needed as a fall-back
  512. * attaching method if there are some on-flash table corruptions.
  513. */
  514. static int attach_by_scanning(struct ubi_device *ubi)
  515. {
  516. int err;
  517. struct ubi_scan_info *si;
  518. si = ubi_scan(ubi);
  519. if (IS_ERR(si))
  520. return PTR_ERR(si);
  521. ubi->bad_peb_count = si->bad_peb_count;
  522. ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
  523. ubi->max_ec = si->max_ec;
  524. ubi->mean_ec = si->mean_ec;
  525. err = ubi_read_volume_table(ubi, si);
  526. if (err)
  527. goto out_si;
  528. err = ubi_wl_init_scan(ubi, si);
  529. if (err)
  530. goto out_vtbl;
  531. err = ubi_eba_init_scan(ubi, si);
  532. if (err)
  533. goto out_wl;
  534. ubi_scan_destroy_si(si);
  535. return 0;
  536. out_wl:
  537. ubi_wl_close(ubi);
  538. out_vtbl:
  539. free_internal_volumes(ubi);
  540. vfree(ubi->vtbl);
  541. out_si:
  542. ubi_scan_destroy_si(si);
  543. return err;
  544. }
  545. /**
  546. * io_init - initialize I/O sub-system for a given UBI device.
  547. * @ubi: UBI device description object
  548. *
  549. * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are
  550. * assumed:
  551. * o EC header is always at offset zero - this cannot be changed;
  552. * o VID header starts just after the EC header at the closest address
  553. * aligned to @io->hdrs_min_io_size;
  554. * o data starts just after the VID header at the closest address aligned to
  555. * @io->min_io_size
  556. *
  557. * This function returns zero in case of success and a negative error code in
  558. * case of failure.
  559. */
  560. static int io_init(struct ubi_device *ubi)
  561. {
  562. if (ubi->mtd->numeraseregions != 0) {
  563. /*
  564. * Some flashes have several erase regions. Different regions
  565. * may have different eraseblock size and other
  566. * characteristics. It looks like mostly multi-region flashes
  567. * have one "main" region and one or more small regions to
  568. * store boot loader code or boot parameters or whatever. I
  569. * guess we should just pick the largest region. But this is
  570. * not implemented.
  571. */
  572. ubi_err("multiple regions, not implemented");
  573. return -EINVAL;
  574. }
  575. if (ubi->vid_hdr_offset < 0)
  576. return -EINVAL;
  577. /*
  578. * Note, in this implementation we support MTD devices with 0x7FFFFFFF
  579. * physical eraseblocks maximum.
  580. */
  581. ubi->peb_size = ubi->mtd->erasesize;
  582. ubi->peb_count = mtd_div_by_eb(ubi->mtd->size, ubi->mtd);
  583. ubi->flash_size = ubi->mtd->size;
  584. if (ubi->mtd->block_isbad && ubi->mtd->block_markbad)
  585. ubi->bad_allowed = 1;
  586. if (ubi->mtd->type == MTD_NORFLASH) {
  587. ubi_assert(ubi->mtd->writesize == 1);
  588. ubi->nor_flash = 1;
  589. }
  590. ubi->min_io_size = ubi->mtd->writesize;
  591. ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
  592. /*
  593. * Make sure minimal I/O unit is power of 2. Note, there is no
  594. * fundamental reason for this assumption. It is just an optimization
  595. * which allows us to avoid costly division operations.
  596. */
  597. if (!is_power_of_2(ubi->min_io_size)) {
  598. ubi_err("min. I/O unit (%d) is not power of 2",
  599. ubi->min_io_size);
  600. return -EINVAL;
  601. }
  602. ubi_assert(ubi->hdrs_min_io_size > 0);
  603. ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);
  604. ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);
  605. /* Calculate default aligned sizes of EC and VID headers */
  606. ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
  607. ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
  608. dbg_msg("min_io_size %d", ubi->min_io_size);
  609. dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
  610. dbg_msg("ec_hdr_alsize %d", ubi->ec_hdr_alsize);
  611. dbg_msg("vid_hdr_alsize %d", ubi->vid_hdr_alsize);
  612. if (ubi->vid_hdr_offset == 0)
  613. /* Default offset */
  614. ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =
  615. ubi->ec_hdr_alsize;
  616. else {
  617. ubi->vid_hdr_aloffset = ubi->vid_hdr_offset &
  618. ~(ubi->hdrs_min_io_size - 1);
  619. ubi->vid_hdr_shift = ubi->vid_hdr_offset -
  620. ubi->vid_hdr_aloffset;
  621. }
  622. /* Similar for the data offset */
  623. ubi->leb_start = ubi->vid_hdr_offset + UBI_EC_HDR_SIZE;
  624. ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
  625. dbg_msg("vid_hdr_offset %d", ubi->vid_hdr_offset);
  626. dbg_msg("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);
  627. dbg_msg("vid_hdr_shift %d", ubi->vid_hdr_shift);
  628. dbg_msg("leb_start %d", ubi->leb_start);
  629. /* The shift must be aligned to 32-bit boundary */
  630. if (ubi->vid_hdr_shift % 4) {
  631. ubi_err("unaligned VID header shift %d",
  632. ubi->vid_hdr_shift);
  633. return -EINVAL;
  634. }
  635. /* Check sanity */
  636. if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE ||
  637. ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE ||
  638. ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE ||
  639. ubi->leb_start & (ubi->min_io_size - 1)) {
  640. ubi_err("bad VID header (%d) or data offsets (%d)",
  641. ubi->vid_hdr_offset, ubi->leb_start);
  642. return -EINVAL;
  643. }
  644. /*
  645. * Set maximum amount of physical erroneous eraseblocks to be 10%.
  646. * Erroneous PEB are those which have read errors.
  647. */
  648. ubi->max_erroneous = ubi->peb_count / 10;
  649. if (ubi->max_erroneous < 16)
  650. ubi->max_erroneous = 16;
  651. dbg_msg("max_erroneous %d", ubi->max_erroneous);
  652. /*
  653. * It may happen that EC and VID headers are situated in one minimal
  654. * I/O unit. In this case we can only accept this UBI image in
  655. * read-only mode.
  656. */
  657. if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {
  658. ubi_warn("EC and VID headers are in the same minimal I/O unit, "
  659. "switch to read-only mode");
  660. ubi->ro_mode = 1;
  661. }
  662. ubi->leb_size = ubi->peb_size - ubi->leb_start;
  663. if (!(ubi->mtd->flags & MTD_WRITEABLE)) {
  664. ubi_msg("MTD device %d is write-protected, attach in "
  665. "read-only mode", ubi->mtd->index);
  666. ubi->ro_mode = 1;
  667. }
  668. ubi_msg("physical eraseblock size: %d bytes (%d KiB)",
  669. ubi->peb_size, ubi->peb_size >> 10);
  670. ubi_msg("logical eraseblock size: %d bytes", ubi->leb_size);
  671. ubi_msg("smallest flash I/O unit: %d", ubi->min_io_size);
  672. if (ubi->hdrs_min_io_size != ubi->min_io_size)
  673. ubi_msg("sub-page size: %d",
  674. ubi->hdrs_min_io_size);
  675. ubi_msg("VID header offset: %d (aligned %d)",
  676. ubi->vid_hdr_offset, ubi->vid_hdr_aloffset);
  677. ubi_msg("data offset: %d", ubi->leb_start);
  678. /*
  679. * Note, ideally, we have to initialize ubi->bad_peb_count here. But
  680. * unfortunately, MTD does not provide this information. We should loop
  681. * over all physical eraseblocks and invoke mtd->block_is_bad() for
  682. * each physical eraseblock. So, we skip ubi->bad_peb_count
  683. * uninitialized and initialize it after scanning.
  684. */
  685. return 0;
  686. }
  687. /**
  688. * autoresize - re-size the volume which has the "auto-resize" flag set.
  689. * @ubi: UBI device description object
  690. * @vol_id: ID of the volume to re-size
  691. *
  692. * This function re-sizes the volume marked by the @UBI_VTBL_AUTORESIZE_FLG in
  693. * the volume table to the largest possible size. See comments in ubi-header.h
  694. * for more description of the flag. Returns zero in case of success and a
  695. * negative error code in case of failure.
  696. */
  697. static int autoresize(struct ubi_device *ubi, int vol_id)
  698. {
  699. struct ubi_volume_desc desc;
  700. struct ubi_volume *vol = ubi->volumes[vol_id];
  701. int err, old_reserved_pebs = vol->reserved_pebs;
  702. /*
  703. * Clear the auto-resize flag in the volume in-memory copy of the
  704. * volume table, and 'ubi_resize_volume()' will propagate this change
  705. * to the flash.
  706. */
  707. ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG;
  708. if (ubi->avail_pebs == 0) {
  709. struct ubi_vtbl_record vtbl_rec;
  710. /*
  711. * No available PEBs to re-size the volume, clear the flag on
  712. * flash and exit.
  713. */
  714. memcpy(&vtbl_rec, &ubi->vtbl[vol_id],
  715. sizeof(struct ubi_vtbl_record));
  716. err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
  717. if (err)
  718. ubi_err("cannot clean auto-resize flag for volume %d",
  719. vol_id);
  720. } else {
  721. desc.vol = vol;
  722. err = ubi_resize_volume(&desc,
  723. old_reserved_pebs + ubi->avail_pebs);
  724. if (err)
  725. ubi_err("cannot auto-resize volume %d", vol_id);
  726. }
  727. if (err)
  728. return err;
  729. ubi_msg("volume %d (\"%s\") re-sized from %d to %d LEBs", vol_id,
  730. vol->name, old_reserved_pebs, vol->reserved_pebs);
  731. return 0;
  732. }
  733. /**
  734. * ubi_attach_mtd_dev - attach an MTD device.
  735. * @mtd: MTD device description object
  736. * @ubi_num: number to assign to the new UBI device
  737. * @vid_hdr_offset: VID header offset
  738. *
  739. * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number
  740. * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in
  741. * which case this function finds a vacant device number and assigns it
  742. * automatically. Returns the new UBI device number in case of success and a
  743. * negative error code in case of failure.
  744. *
  745. * Note, the invocations of this function has to be serialized by the
  746. * @ubi_devices_mutex.
  747. */
  748. int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
  749. {
  750. struct ubi_device *ubi;
  751. int i, err, ref = 0;
  752. /*
  753. * Check if we already have the same MTD device attached.
  754. *
  755. * Note, this function assumes that UBI devices creations and deletions
  756. * are serialized, so it does not take the &ubi_devices_lock.
  757. */
  758. for (i = 0; i < UBI_MAX_DEVICES; i++) {
  759. ubi = ubi_devices[i];
  760. if (ubi && mtd->index == ubi->mtd->index) {
  761. dbg_err("mtd%d is already attached to ubi%d",
  762. mtd->index, i);
  763. return -EEXIST;
  764. }
  765. }
  766. /*
  767. * Make sure this MTD device is not emulated on top of an UBI volume
  768. * already. Well, generally this recursion works fine, but there are
  769. * different problems like the UBI module takes a reference to itself
  770. * by attaching (and thus, opening) the emulated MTD device. This
  771. * results in inability to unload the module. And in general it makes
  772. * no sense to attach emulated MTD devices, so we prohibit this.
  773. */
  774. if (mtd->type == MTD_UBIVOLUME) {
  775. ubi_err("refuse attaching mtd%d - it is already emulated on "
  776. "top of UBI", mtd->index);
  777. return -EINVAL;
  778. }
  779. if (ubi_num == UBI_DEV_NUM_AUTO) {
  780. /* Search for an empty slot in the @ubi_devices array */
  781. for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++)
  782. if (!ubi_devices[ubi_num])
  783. break;
  784. if (ubi_num == UBI_MAX_DEVICES) {
  785. dbg_err("only %d UBI devices may be created",
  786. UBI_MAX_DEVICES);
  787. return -ENFILE;
  788. }
  789. } else {
  790. if (ubi_num >= UBI_MAX_DEVICES)
  791. return -EINVAL;
  792. /* Make sure ubi_num is not busy */
  793. if (ubi_devices[ubi_num]) {
  794. dbg_err("ubi%d already exists", ubi_num);
  795. return -EEXIST;
  796. }
  797. }
  798. ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL);
  799. if (!ubi)
  800. return -ENOMEM;
  801. ubi->mtd = mtd;
  802. ubi->ubi_num = ubi_num;
  803. ubi->vid_hdr_offset = vid_hdr_offset;
  804. ubi->autoresize_vol_id = -1;
  805. mutex_init(&ubi->buf_mutex);
  806. mutex_init(&ubi->ckvol_mutex);
  807. mutex_init(&ubi->device_mutex);
  808. spin_lock_init(&ubi->volumes_lock);
  809. ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num);
  810. err = io_init(ubi);
  811. if (err)
  812. goto out_free;
  813. err = -ENOMEM;
  814. ubi->peb_buf1 = vmalloc(ubi->peb_size);
  815. if (!ubi->peb_buf1)
  816. goto out_free;
  817. ubi->peb_buf2 = vmalloc(ubi->peb_size);
  818. if (!ubi->peb_buf2)
  819. goto out_free;
  820. #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
  821. mutex_init(&ubi->dbg_buf_mutex);
  822. ubi->dbg_peb_buf = vmalloc(ubi->peb_size);
  823. if (!ubi->dbg_peb_buf)
  824. goto out_free;
  825. #endif
  826. err = attach_by_scanning(ubi);
  827. if (err) {
  828. dbg_err("failed to attach by scanning, error %d", err);
  829. goto out_free;
  830. }
  831. if (ubi->autoresize_vol_id != -1) {
  832. err = autoresize(ubi, ubi->autoresize_vol_id);
  833. if (err)
  834. goto out_detach;
  835. }
  836. err = uif_init(ubi, &ref);
  837. if (err)
  838. goto out_detach;
  839. ubi->bgt_thread = kthread_create(ubi_thread, ubi, ubi->bgt_name);
  840. if (IS_ERR(ubi->bgt_thread)) {
  841. err = PTR_ERR(ubi->bgt_thread);
  842. ubi_err("cannot spawn \"%s\", error %d", ubi->bgt_name,
  843. err);
  844. goto out_uif;
  845. }
  846. ubi_msg("attached mtd%d to ubi%d", mtd->index, ubi_num);
  847. ubi_msg("MTD device name: \"%s\"", mtd->name);
  848. ubi_msg("MTD device size: %llu MiB", ubi->flash_size >> 20);
  849. ubi_msg("number of good PEBs: %d", ubi->good_peb_count);
  850. ubi_msg("number of bad PEBs: %d", ubi->bad_peb_count);
  851. ubi_msg("max. allowed volumes: %d", ubi->vtbl_slots);
  852. ubi_msg("wear-leveling threshold: %d", CONFIG_MTD_UBI_WL_THRESHOLD);
  853. ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT);
  854. ubi_msg("number of user volumes: %d",
  855. ubi->vol_count - UBI_INT_VOL_COUNT);
  856. ubi_msg("available PEBs: %d", ubi->avail_pebs);
  857. ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs);
  858. ubi_msg("number of PEBs reserved for bad PEB handling: %d",
  859. ubi->beb_rsvd_pebs);
  860. ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
  861. ubi_msg("image sequence number: %d", ubi->image_seq);
  862. /*
  863. * The below lock makes sure we do not race with 'ubi_thread()' which
  864. * checks @ubi->thread_enabled. Otherwise we may fail to wake it up.
  865. */
  866. spin_lock(&ubi->wl_lock);
  867. if (!DBG_DISABLE_BGT)
  868. ubi->thread_enabled = 1;
  869. wake_up_process(ubi->bgt_thread);
  870. spin_unlock(&ubi->wl_lock);
  871. ubi_devices[ubi_num] = ubi;
  872. ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL);
  873. return ubi_num;
  874. out_uif:
  875. uif_close(ubi);
  876. out_detach:
  877. ubi_wl_close(ubi);
  878. free_internal_volumes(ubi);
  879. vfree(ubi->vtbl);
  880. out_free:
  881. vfree(ubi->peb_buf1);
  882. vfree(ubi->peb_buf2);
  883. #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
  884. vfree(ubi->dbg_peb_buf);
  885. #endif
  886. if (ref)
  887. put_device(&ubi->dev);
  888. else
  889. kfree(ubi);
  890. return err;
  891. }
  892. /**
  893. * ubi_detach_mtd_dev - detach an MTD device.
  894. * @ubi_num: UBI device number to detach from
  895. * @anyway: detach MTD even if device reference count is not zero
  896. *
  897. * This function destroys an UBI device number @ubi_num and detaches the
  898. * underlying MTD device. Returns zero in case of success and %-EBUSY if the
  899. * UBI device is busy and cannot be destroyed, and %-EINVAL if it does not
  900. * exist.
  901. *
  902. * Note, the invocations of this function has to be serialized by the
  903. * @ubi_devices_mutex.
  904. */
  905. int ubi_detach_mtd_dev(int ubi_num, int anyway)
  906. {
  907. struct ubi_device *ubi;
  908. if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES)
  909. return -EINVAL;
  910. ubi = ubi_get_device(ubi_num);
  911. if (!ubi)
  912. return -EINVAL;
  913. spin_lock(&ubi_devices_lock);
  914. put_device(&ubi->dev);
  915. ubi->ref_count -= 1;
  916. if (ubi->ref_count) {
  917. if (!anyway) {
  918. spin_unlock(&ubi_devices_lock);
  919. return -EBUSY;
  920. }
  921. /* This may only happen if there is a bug */
  922. ubi_err("%s reference count %d, destroy anyway",
  923. ubi->ubi_name, ubi->ref_count);
  924. }
  925. ubi_devices[ubi_num] = NULL;
  926. spin_unlock(&ubi_devices_lock);
  927. ubi_assert(ubi_num == ubi->ubi_num);
  928. ubi_notify_all(ubi, UBI_VOLUME_REMOVED, NULL);
  929. dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);
  930. /*
  931. * Before freeing anything, we have to stop the background thread to
  932. * prevent it from doing anything on this device while we are freeing.
  933. */
  934. if (ubi->bgt_thread)
  935. kthread_stop(ubi->bgt_thread);
  936. /*
  937. * Get a reference to the device in order to prevent 'dev_release()'
  938. * from freeing the @ubi object.
  939. */
  940. get_device(&ubi->dev);
  941. uif_close(ubi);
  942. ubi_wl_close(ubi);
  943. free_internal_volumes(ubi);
  944. vfree(ubi->vtbl);
  945. put_mtd_device(ubi->mtd);
  946. vfree(ubi->peb_buf1);
  947. vfree(ubi->peb_buf2);
  948. #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
  949. vfree(ubi->dbg_peb_buf);
  950. #endif
  951. ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num);
  952. put_device(&ubi->dev);
  953. return 0;
  954. }
  955. /**
  956. * open_mtd_by_chdev - open an MTD device by its character device node path.
  957. * @mtd_dev: MTD character device node path
  958. *
  959. * This helper function opens an MTD device by its character node device path.
  960. * Returns MTD device description object in case of success and a negative
  961. * error code in case of failure.
  962. */
  963. static struct mtd_info * __init open_mtd_by_chdev(const char *mtd_dev)
  964. {
  965. int err, major, minor, mode;
  966. struct path path;
  967. /* Probably this is an MTD character device node path */
  968. err = kern_path(mtd_dev, LOOKUP_FOLLOW, &path);
  969. if (err)
  970. return ERR_PTR(err);
  971. /* MTD device number is defined by the major / minor numbers */
  972. major = imajor(path.dentry->d_inode);
  973. minor = iminor(path.dentry->d_inode);
  974. mode = path.dentry->d_inode->i_mode;
  975. path_put(&path);
  976. if (major != MTD_CHAR_MAJOR || !S_ISCHR(mode))
  977. return ERR_PTR(-EINVAL);
  978. if (minor & 1)
  979. /*
  980. * Just do not think the "/dev/mtdrX" devices support is need,
  981. * so do not support them to avoid doing extra work.
  982. */
  983. return ERR_PTR(-EINVAL);
  984. return get_mtd_device(NULL, minor / 2);
  985. }
  986. /**
  987. * open_mtd_device - open MTD device by name, character device path, or number.
  988. * @mtd_dev: name, character device node path, or MTD device device number
  989. *
  990. * This function tries to open and MTD device described by @mtd_dev string,
  991. * which is first treated as ASCII MTD device number, and if it is not true, it
  992. * is treated as MTD device name, and if that is also not true, it is treated
  993. * as MTD character device node path. Returns MTD device description object in
  994. * case of success and a negative error code in case of failure.
  995. */
  996. static struct mtd_info * __init open_mtd_device(const char *mtd_dev)
  997. {
  998. struct mtd_info *mtd;
  999. int mtd_num;
  1000. char *endp;
  1001. mtd_num = simple_strtoul(mtd_dev, &endp, 0);
  1002. if (*endp != '\0' || mtd_dev == endp) {
  1003. /*
  1004. * This does not look like an ASCII integer, probably this is
  1005. * MTD device name.
  1006. */
  1007. mtd = get_mtd_device_nm(mtd_dev);
  1008. if (IS_ERR(mtd) && PTR_ERR(mtd) == -ENODEV)
  1009. /* Probably this is an MTD character device node path */
  1010. mtd = open_mtd_by_chdev(mtd_dev);
  1011. } else
  1012. mtd = get_mtd_device(NULL, mtd_num);
  1013. return mtd;
  1014. }
  1015. static int __init ubi_init(void)
  1016. {
  1017. int err, i, k;
  1018. /* Ensure that EC and VID headers have correct size */
  1019. BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64);
  1020. BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64);
  1021. if (mtd_devs > UBI_MAX_DEVICES) {
  1022. ubi_err("too many MTD devices, maximum is %d", UBI_MAX_DEVICES);
  1023. return -EINVAL;
  1024. }
  1025. /* Create base sysfs directory and sysfs files */
  1026. ubi_class = class_create(THIS_MODULE, UBI_NAME_STR);
  1027. if (IS_ERR(ubi_class)) {
  1028. err = PTR_ERR(ubi_class);
  1029. ubi_err("cannot create UBI class");
  1030. goto out;
  1031. }
  1032. err = class_create_file(ubi_class, &ubi_version);
  1033. if (err) {
  1034. ubi_err("cannot create sysfs file");
  1035. goto out_class;
  1036. }
  1037. err = misc_register(&ubi_ctrl_cdev);
  1038. if (err) {
  1039. ubi_err("cannot register device");
  1040. goto out_version;
  1041. }
  1042. ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab",
  1043. sizeof(struct ubi_wl_entry),
  1044. 0, 0, NULL);
  1045. if (!ubi_wl_entry_slab)
  1046. goto out_dev_unreg;
  1047. /* Attach MTD devices */
  1048. for (i = 0; i < mtd_devs; i++) {
  1049. struct mtd_dev_param *p = &mtd_dev_param[i];
  1050. struct mtd_info *mtd;
  1051. cond_resched();
  1052. mtd = open_mtd_device(p->name);
  1053. if (IS_ERR(mtd)) {
  1054. err = PTR_ERR(mtd);
  1055. goto out_detach;
  1056. }
  1057. mutex_lock(&ubi_devices_mutex);
  1058. err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO,
  1059. p->vid_hdr_offs);
  1060. mutex_unlock(&ubi_devices_mutex);
  1061. if (err < 0) {
  1062. put_mtd_device(mtd);
  1063. ubi_err("cannot attach mtd%d", mtd->index);
  1064. goto out_detach;
  1065. }
  1066. }
  1067. return 0;
  1068. out_detach:
  1069. for (k = 0; k < i; k++)
  1070. if (ubi_devices[k]) {
  1071. mutex_lock(&ubi_devices_mutex);
  1072. ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1);
  1073. mutex_unlock(&ubi_devices_mutex);
  1074. }
  1075. kmem_cache_destroy(ubi_wl_entry_slab);
  1076. out_dev_unreg:
  1077. misc_deregister(&ubi_ctrl_cdev);
  1078. out_version:
  1079. class_remove_file(ubi_class, &ubi_version);
  1080. out_class:
  1081. class_destroy(ubi_class);
  1082. out:
  1083. ubi_err("UBI error: cannot initialize UBI, error %d", err);
  1084. return err;
  1085. }
  1086. module_init(ubi_init);
  1087. static void __exit ubi_exit(void)
  1088. {
  1089. int i;
  1090. for (i = 0; i < UBI_MAX_DEVICES; i++)
  1091. if (ubi_devices[i]) {
  1092. mutex_lock(&ubi_devices_mutex);
  1093. ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1);
  1094. mutex_unlock(&ubi_devices_mutex);
  1095. }
  1096. kmem_cache_destroy(ubi_wl_entry_slab);
  1097. misc_deregister(&ubi_ctrl_cdev);
  1098. class_remove_file(ubi_class, &ubi_version);
  1099. class_destroy(ubi_class);
  1100. }
  1101. module_exit(ubi_exit);
  1102. /**
  1103. * bytes_str_to_int - convert a number of bytes string into an integer.
  1104. * @str: the string to convert
  1105. *
  1106. * This function returns positive resulting integer in case of success and a
  1107. * negative error code in case of failure.
  1108. */
  1109. static int __init bytes_str_to_int(const char *str)
  1110. {
  1111. char *endp;
  1112. unsigned long result;
  1113. result = simple_strtoul(str, &endp, 0);
  1114. if (str == endp || result >= INT_MAX) {
  1115. printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n",
  1116. str);
  1117. return -EINVAL;
  1118. }
  1119. switch (*endp) {
  1120. case 'G':
  1121. result *= 1024;
  1122. case 'M':
  1123. result *= 1024;
  1124. case 'K':
  1125. result *= 1024;
  1126. if (endp[1] == 'i' && endp[2] == 'B')
  1127. endp += 2;
  1128. case '\0':
  1129. break;
  1130. default:
  1131. printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n",
  1132. str);
  1133. return -EINVAL;
  1134. }
  1135. return result;
  1136. }
  1137. /**
  1138. * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter.
  1139. * @val: the parameter value to parse
  1140. * @kp: not used
  1141. *
  1142. * This function returns zero in case of success and a negative error code in
  1143. * case of error.
  1144. */
  1145. static int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp)
  1146. {
  1147. int i, len;
  1148. struct mtd_dev_param *p;
  1149. char buf[MTD_PARAM_LEN_MAX];
  1150. char *pbuf = &buf[0];
  1151. char *tokens[2] = {NULL, NULL};
  1152. if (!val)
  1153. return -EINVAL;
  1154. if (mtd_devs == UBI_MAX_DEVICES) {
  1155. printk(KERN_ERR "UBI error: too many parameters, max. is %d\n",
  1156. UBI_MAX_DEVICES);
  1157. return -EINVAL;
  1158. }
  1159. len = strnlen(val, MTD_PARAM_LEN_MAX);
  1160. if (len == MTD_PARAM_LEN_MAX) {
  1161. printk(KERN_ERR "UBI error: parameter \"%s\" is too long, "
  1162. "max. is %d\n", val, MTD_PARAM_LEN_MAX);
  1163. return -EINVAL;
  1164. }
  1165. if (len == 0) {
  1166. printk(KERN_WARNING "UBI warning: empty 'mtd=' parameter - "
  1167. "ignored\n");
  1168. return 0;
  1169. }
  1170. strcpy(buf, val);
  1171. /* Get rid of the final newline */
  1172. if (buf[len - 1] == '\n')
  1173. buf[len - 1] = '\0';
  1174. for (i = 0; i < 2; i++)
  1175. tokens[i] = strsep(&pbuf, ",");
  1176. if (pbuf) {
  1177. printk(KERN_ERR "UBI error: too many arguments at \"%s\"\n",
  1178. val);
  1179. return -EINVAL;
  1180. }
  1181. p = &mtd_dev_param[mtd_devs];
  1182. strcpy(&p->name[0], tokens[0]);
  1183. if (tokens[1])
  1184. p->vid_hdr_offs = bytes_str_to_int(tokens[1]);
  1185. if (p->vid_hdr_offs < 0)
  1186. return p->vid_hdr_offs;
  1187. mtd_devs += 1;
  1188. return 0;
  1189. }
  1190. module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000);
  1191. MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: "
  1192. "mtd=<name|num|path>[,<vid_hdr_offs>].\n"
  1193. "Multiple \"mtd\" parameters may be specified.\n"
  1194. "MTD devices may be specified by their number, name, or "
  1195. "path to the MTD character device node.\n"
  1196. "Optional \"vid_hdr_offs\" parameter specifies UBI VID "
  1197. "header position to be used by UBI.\n"
  1198. "Example 1: mtd=/dev/mtd0 - attach MTD device "
  1199. "/dev/mtd0.\n"
  1200. "Example 2: mtd=content,1984 mtd=4 - attach MTD device "
  1201. "with name \"content\" using VID header offset 1984, and "
  1202. "MTD device number 4 with default VID header offset.");
  1203. MODULE_VERSION(__stringify(UBI_VERSION));
  1204. MODULE_DESCRIPTION("UBI - Unsorted Block Images");
  1205. MODULE_AUTHOR("Artem Bityutskiy");
  1206. MODULE_LICENSE("GPL");