fw_env.c 37 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724
  1. /*
  2. * (C) Copyright 2000-2010
  3. * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  4. *
  5. * (C) Copyright 2008
  6. * Guennadi Liakhovetski, DENX Software Engineering, lg@denx.de.
  7. *
  8. * SPDX-License-Identifier: GPL-2.0+
  9. */
  10. #define _GNU_SOURCE
  11. #include <compiler.h>
  12. #include <errno.h>
  13. #include <env_flags.h>
  14. #include <fcntl.h>
  15. #include <linux/fs.h>
  16. #include <linux/stringify.h>
  17. #include <ctype.h>
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <stddef.h>
  21. #include <string.h>
  22. #include <sys/types.h>
  23. #include <sys/ioctl.h>
  24. #include <sys/stat.h>
  25. #include <unistd.h>
  26. #include <dirent.h>
  27. #ifdef MTD_OLD
  28. # include <stdint.h>
  29. # include <linux/mtd/mtd.h>
  30. #else
  31. # define __user /* nothing */
  32. # include <mtd/mtd-user.h>
  33. #endif
  34. #include <mtd/ubi-user.h>
  35. #include "fw_env_private.h"
  36. #include "fw_env.h"
  37. struct env_opts default_opts = {
  38. #ifdef CONFIG_FILE
  39. .config_file = CONFIG_FILE
  40. #endif
  41. };
  42. #define DIV_ROUND_UP(n, d) (((n) + (d) - 1) / (d))
  43. #define min(x, y) ({ \
  44. typeof(x) _min1 = (x); \
  45. typeof(y) _min2 = (y); \
  46. (void) (&_min1 == &_min2); \
  47. _min1 < _min2 ? _min1 : _min2; })
  48. struct envdev_s {
  49. const char *devname; /* Device name */
  50. long long devoff; /* Device offset */
  51. ulong env_size; /* environment size */
  52. ulong erase_size; /* device erase size */
  53. ulong env_sectors; /* number of environment sectors */
  54. uint8_t mtd_type; /* type of the MTD device */
  55. int is_ubi; /* set if we use UBI volume */
  56. };
  57. static struct envdev_s envdevices[2] =
  58. {
  59. {
  60. .mtd_type = MTD_ABSENT,
  61. }, {
  62. .mtd_type = MTD_ABSENT,
  63. },
  64. };
  65. static int dev_current;
  66. #define DEVNAME(i) envdevices[(i)].devname
  67. #define DEVOFFSET(i) envdevices[(i)].devoff
  68. #define ENVSIZE(i) envdevices[(i)].env_size
  69. #define DEVESIZE(i) envdevices[(i)].erase_size
  70. #define ENVSECTORS(i) envdevices[(i)].env_sectors
  71. #define DEVTYPE(i) envdevices[(i)].mtd_type
  72. #define IS_UBI(i) envdevices[(i)].is_ubi
  73. #define CUR_ENVSIZE ENVSIZE(dev_current)
  74. static unsigned long usable_envsize;
  75. #define ENV_SIZE usable_envsize
  76. struct env_image_single {
  77. uint32_t crc; /* CRC32 over data bytes */
  78. char data[];
  79. };
  80. struct env_image_redundant {
  81. uint32_t crc; /* CRC32 over data bytes */
  82. unsigned char flags; /* active or obsolete */
  83. char data[];
  84. };
  85. enum flag_scheme {
  86. FLAG_NONE,
  87. FLAG_BOOLEAN,
  88. FLAG_INCREMENTAL,
  89. };
  90. struct environment {
  91. void *image;
  92. uint32_t *crc;
  93. unsigned char *flags;
  94. char *data;
  95. enum flag_scheme flag_scheme;
  96. };
  97. static struct environment environment = {
  98. .flag_scheme = FLAG_NONE,
  99. };
  100. static int HaveRedundEnv = 0;
  101. static unsigned char active_flag = 1;
  102. /* obsolete_flag must be 0 to efficiently set it on NOR flash without erasing */
  103. static unsigned char obsolete_flag = 0;
  104. #define DEFAULT_ENV_INSTANCE_STATIC
  105. #include <env_default.h>
  106. #define UBI_DEV_START "/dev/ubi"
  107. #define UBI_SYSFS "/sys/class/ubi"
  108. #define UBI_VOL_NAME_PATT "ubi%d_%d"
  109. static int is_ubi_devname(const char *devname)
  110. {
  111. return !strncmp(devname, UBI_DEV_START, sizeof(UBI_DEV_START) - 1);
  112. }
  113. static int ubi_check_volume_sysfs_name(const char *volume_sysfs_name,
  114. const char *volname)
  115. {
  116. char path[256];
  117. FILE *file;
  118. char *name;
  119. int ret;
  120. strcpy(path, UBI_SYSFS "/");
  121. strcat(path, volume_sysfs_name);
  122. strcat(path, "/name");
  123. file = fopen(path, "r");
  124. if (!file)
  125. return -1;
  126. ret = fscanf(file, "%ms", &name);
  127. fclose(file);
  128. if (ret <= 0 || !name) {
  129. fprintf(stderr,
  130. "Failed to read from file %s, ret = %d, name = %s\n",
  131. path, ret, name);
  132. return -1;
  133. }
  134. if (!strcmp(name, volname)) {
  135. free(name);
  136. return 0;
  137. }
  138. free(name);
  139. return -1;
  140. }
  141. static int ubi_get_volnum_by_name(int devnum, const char *volname)
  142. {
  143. DIR *sysfs_ubi;
  144. struct dirent *dirent;
  145. int ret;
  146. int tmp_devnum;
  147. int volnum;
  148. sysfs_ubi = opendir(UBI_SYSFS);
  149. if (!sysfs_ubi)
  150. return -1;
  151. #ifdef DEBUG
  152. fprintf(stderr, "Looking for volume name \"%s\"\n", volname);
  153. #endif
  154. while (1) {
  155. dirent = readdir(sysfs_ubi);
  156. if (!dirent)
  157. return -1;
  158. ret = sscanf(dirent->d_name, UBI_VOL_NAME_PATT,
  159. &tmp_devnum, &volnum);
  160. if (ret == 2 && devnum == tmp_devnum) {
  161. if (ubi_check_volume_sysfs_name(dirent->d_name,
  162. volname) == 0)
  163. return volnum;
  164. }
  165. }
  166. return -1;
  167. }
  168. static int ubi_get_devnum_by_devname(const char *devname)
  169. {
  170. int devnum;
  171. int ret;
  172. ret = sscanf(devname + sizeof(UBI_DEV_START) - 1, "%d", &devnum);
  173. if (ret != 1)
  174. return -1;
  175. return devnum;
  176. }
  177. static const char *ubi_get_volume_devname(const char *devname,
  178. const char *volname)
  179. {
  180. char *volume_devname;
  181. int volnum;
  182. int devnum;
  183. int ret;
  184. devnum = ubi_get_devnum_by_devname(devname);
  185. if (devnum < 0)
  186. return NULL;
  187. volnum = ubi_get_volnum_by_name(devnum, volname);
  188. if (volnum < 0)
  189. return NULL;
  190. ret = asprintf(&volume_devname, "%s_%d", devname, volnum);
  191. if (ret < 0)
  192. return NULL;
  193. #ifdef DEBUG
  194. fprintf(stderr, "Found ubi volume \"%s:%s\" -> %s\n",
  195. devname, volname, volume_devname);
  196. #endif
  197. return volume_devname;
  198. }
  199. static void ubi_check_dev(unsigned int dev_id)
  200. {
  201. char *devname = (char *)DEVNAME(dev_id);
  202. char *pname;
  203. const char *volname = NULL;
  204. const char *volume_devname;
  205. if (!is_ubi_devname(DEVNAME(dev_id)))
  206. return;
  207. IS_UBI(dev_id) = 1;
  208. for (pname = devname; *pname != '\0'; pname++) {
  209. if (*pname == ':') {
  210. *pname = '\0';
  211. volname = pname + 1;
  212. break;
  213. }
  214. }
  215. if (volname) {
  216. /* Let's find real volume device name */
  217. volume_devname = ubi_get_volume_devname(devname, volname);
  218. if (!volume_devname) {
  219. fprintf(stderr, "Didn't found ubi volume \"%s\"\n",
  220. volname);
  221. return;
  222. }
  223. free(devname);
  224. DEVNAME(dev_id) = volume_devname;
  225. }
  226. }
  227. static int ubi_update_start(int fd, int64_t bytes)
  228. {
  229. if (ioctl(fd, UBI_IOCVOLUP, &bytes))
  230. return -1;
  231. return 0;
  232. }
  233. static int ubi_read(int fd, void *buf, size_t count)
  234. {
  235. ssize_t ret;
  236. while (count > 0) {
  237. ret = read(fd, buf, count);
  238. if (ret > 0) {
  239. count -= ret;
  240. buf += ret;
  241. continue;
  242. }
  243. if (ret == 0) {
  244. /*
  245. * Happens in case of too short volume data size. If we
  246. * return error status we will fail it will be treated
  247. * as UBI device error.
  248. *
  249. * Leave catching this error to CRC check.
  250. */
  251. fprintf(stderr, "Warning: end of data on ubi volume\n");
  252. return 0;
  253. } else if (errno == EBADF) {
  254. /*
  255. * Happens in case of corrupted volume. The same as
  256. * above, we cannot return error now, as we will still
  257. * be able to successfully write environment later.
  258. */
  259. fprintf(stderr, "Warning: corrupted volume?\n");
  260. return 0;
  261. } else if (errno == EINTR) {
  262. continue;
  263. }
  264. fprintf(stderr, "Cannot read %u bytes from ubi volume, %s\n",
  265. (unsigned int)count, strerror(errno));
  266. return -1;
  267. }
  268. return 0;
  269. }
  270. static int ubi_write(int fd, const void *buf, size_t count)
  271. {
  272. ssize_t ret;
  273. while (count > 0) {
  274. ret = write(fd, buf, count);
  275. if (ret <= 0) {
  276. if (ret < 0 && errno == EINTR)
  277. continue;
  278. fprintf(stderr, "Cannot write %u bytes to ubi volume\n",
  279. (unsigned int)count);
  280. return -1;
  281. }
  282. count -= ret;
  283. buf += ret;
  284. }
  285. return 0;
  286. }
  287. static int flash_io (int mode);
  288. static int parse_config(struct env_opts *opts);
  289. #if defined(CONFIG_FILE)
  290. static int get_config (char *);
  291. #endif
  292. static char *skip_chars(char *s)
  293. {
  294. for (; *s != '\0'; s++) {
  295. if (isblank(*s))
  296. return s;
  297. }
  298. return NULL;
  299. }
  300. static char *skip_blanks(char *s)
  301. {
  302. for (; *s != '\0'; s++) {
  303. if (!isblank(*s))
  304. return s;
  305. }
  306. return NULL;
  307. }
  308. /*
  309. * s1 is either a simple 'name', or a 'name=value' pair.
  310. * s2 is a 'name=value' pair.
  311. * If the names match, return the value of s2, else NULL.
  312. */
  313. static char *envmatch(char *s1, char *s2)
  314. {
  315. if (s1 == NULL || s2 == NULL)
  316. return NULL;
  317. while (*s1 == *s2++)
  318. if (*s1++ == '=')
  319. return s2;
  320. if (*s1 == '\0' && *(s2 - 1) == '=')
  321. return s2;
  322. return NULL;
  323. }
  324. /**
  325. * Search the environment for a variable.
  326. * Return the value, if found, or NULL, if not found.
  327. */
  328. char *fw_getenv (char *name)
  329. {
  330. char *env, *nxt;
  331. for (env = environment.data; *env; env = nxt + 1) {
  332. char *val;
  333. for (nxt = env; *nxt; ++nxt) {
  334. if (nxt >= &environment.data[ENV_SIZE]) {
  335. fprintf (stderr, "## Error: "
  336. "environment not terminated\n");
  337. return NULL;
  338. }
  339. }
  340. val = envmatch (name, env);
  341. if (!val)
  342. continue;
  343. return val;
  344. }
  345. return NULL;
  346. }
  347. /*
  348. * Search the default environment for a variable.
  349. * Return the value, if found, or NULL, if not found.
  350. */
  351. char *fw_getdefenv(char *name)
  352. {
  353. char *env, *nxt;
  354. for (env = default_environment; *env; env = nxt + 1) {
  355. char *val;
  356. for (nxt = env; *nxt; ++nxt) {
  357. if (nxt >= &default_environment[ENV_SIZE]) {
  358. fprintf(stderr, "## Error: "
  359. "default environment not terminated\n");
  360. return NULL;
  361. }
  362. }
  363. val = envmatch(name, env);
  364. if (!val)
  365. continue;
  366. return val;
  367. }
  368. return NULL;
  369. }
  370. /*
  371. * Print the current definition of one, or more, or all
  372. * environment variables
  373. */
  374. int fw_printenv(int argc, char *argv[], int value_only, struct env_opts *opts)
  375. {
  376. int i, rc = 0;
  377. if (value_only && argc != 1) {
  378. fprintf(stderr,
  379. "## Error: `-n' option requires exactly one argument\n");
  380. return -1;
  381. }
  382. if (!opts)
  383. opts = &default_opts;
  384. if (fw_env_open(opts))
  385. return -1;
  386. if (argc == 0) { /* Print all env variables */
  387. char *env, *nxt;
  388. for (env = environment.data; *env; env = nxt + 1) {
  389. for (nxt = env; *nxt; ++nxt) {
  390. if (nxt >= &environment.data[ENV_SIZE]) {
  391. fprintf (stderr, "## Error: "
  392. "environment not terminated\n");
  393. return -1;
  394. }
  395. }
  396. printf ("%s\n", env);
  397. }
  398. fw_env_close(opts);
  399. return 0;
  400. }
  401. for (i = 0; i < argc; ++i) { /* print a subset of env variables */
  402. char *name = argv[i];
  403. char *val = NULL;
  404. val = fw_getenv(name);
  405. if (!val) {
  406. fprintf (stderr, "## Error: \"%s\" not defined\n", name);
  407. rc = -1;
  408. continue;
  409. }
  410. if (value_only) {
  411. puts(val);
  412. break;
  413. }
  414. printf("%s=%s\n", name, val);
  415. }
  416. fw_env_close(opts);
  417. return rc;
  418. }
  419. int fw_env_flush(struct env_opts *opts)
  420. {
  421. int ret;
  422. if (!opts)
  423. opts = &default_opts;
  424. /*
  425. * Update CRC
  426. */
  427. *environment.crc = crc32(0, (uint8_t *) environment.data, ENV_SIZE);
  428. /* write environment back to flash */
  429. if (flash_io(O_RDWR)) {
  430. fprintf(stderr,
  431. "Error: can't write fw_env to flash\n");
  432. return -1;
  433. }
  434. return 0;
  435. }
  436. /*
  437. * Set/Clear a single variable in the environment.
  438. * This is called in sequence to update the environment
  439. * in RAM without updating the copy in flash after each set
  440. */
  441. int fw_env_write(char *name, char *value)
  442. {
  443. int len;
  444. char *env, *nxt;
  445. char *oldval = NULL;
  446. int deleting, creating, overwriting;
  447. /*
  448. * search if variable with this name already exists
  449. */
  450. for (nxt = env = environment.data; *env; env = nxt + 1) {
  451. for (nxt = env; *nxt; ++nxt) {
  452. if (nxt >= &environment.data[ENV_SIZE]) {
  453. fprintf(stderr, "## Error: "
  454. "environment not terminated\n");
  455. errno = EINVAL;
  456. return -1;
  457. }
  458. }
  459. if ((oldval = envmatch (name, env)) != NULL)
  460. break;
  461. }
  462. deleting = (oldval && !(value && strlen(value)));
  463. creating = (!oldval && (value && strlen(value)));
  464. overwriting = (oldval && (value && strlen(value)));
  465. /* check for permission */
  466. if (deleting) {
  467. if (env_flags_validate_varaccess(name,
  468. ENV_FLAGS_VARACCESS_PREVENT_DELETE)) {
  469. printf("Can't delete \"%s\"\n", name);
  470. errno = EROFS;
  471. return -1;
  472. }
  473. } else if (overwriting) {
  474. if (env_flags_validate_varaccess(name,
  475. ENV_FLAGS_VARACCESS_PREVENT_OVERWR)) {
  476. printf("Can't overwrite \"%s\"\n", name);
  477. errno = EROFS;
  478. return -1;
  479. } else if (env_flags_validate_varaccess(name,
  480. ENV_FLAGS_VARACCESS_PREVENT_NONDEF_OVERWR)) {
  481. const char *defval = fw_getdefenv(name);
  482. if (defval == NULL)
  483. defval = "";
  484. if (strcmp(oldval, defval)
  485. != 0) {
  486. printf("Can't overwrite \"%s\"\n", name);
  487. errno = EROFS;
  488. return -1;
  489. }
  490. }
  491. } else if (creating) {
  492. if (env_flags_validate_varaccess(name,
  493. ENV_FLAGS_VARACCESS_PREVENT_CREATE)) {
  494. printf("Can't create \"%s\"\n", name);
  495. errno = EROFS;
  496. return -1;
  497. }
  498. } else
  499. /* Nothing to do */
  500. return 0;
  501. if (deleting || overwriting) {
  502. if (*++nxt == '\0') {
  503. *env = '\0';
  504. } else {
  505. for (;;) {
  506. *env = *nxt++;
  507. if ((*env == '\0') && (*nxt == '\0'))
  508. break;
  509. ++env;
  510. }
  511. }
  512. *++env = '\0';
  513. }
  514. /* Delete only ? */
  515. if (!value || !strlen(value))
  516. return 0;
  517. /*
  518. * Append new definition at the end
  519. */
  520. for (env = environment.data; *env || *(env + 1); ++env);
  521. if (env > environment.data)
  522. ++env;
  523. /*
  524. * Overflow when:
  525. * "name" + "=" + "val" +"\0\0" > CUR_ENVSIZE - (env-environment)
  526. */
  527. len = strlen (name) + 2;
  528. /* add '=' for first arg, ' ' for all others */
  529. len += strlen(value) + 1;
  530. if (len > (&environment.data[ENV_SIZE] - env)) {
  531. fprintf (stderr,
  532. "Error: environment overflow, \"%s\" deleted\n",
  533. name);
  534. return -1;
  535. }
  536. while ((*env = *name++) != '\0')
  537. env++;
  538. *env = '=';
  539. while ((*++env = *value++) != '\0')
  540. ;
  541. /* end is marked with double '\0' */
  542. *++env = '\0';
  543. return 0;
  544. }
  545. /*
  546. * Deletes or sets environment variables. Returns -1 and sets errno error codes:
  547. * 0 - OK
  548. * EINVAL - need at least 1 argument
  549. * EROFS - certain variables ("ethaddr", "serial#") cannot be
  550. * modified or deleted
  551. *
  552. */
  553. int fw_env_set(int argc, char *argv[], struct env_opts *opts)
  554. {
  555. int i;
  556. size_t len;
  557. char *name, **valv;
  558. char *oldval;
  559. char *value = NULL;
  560. int valc;
  561. int ret;
  562. if (!opts)
  563. opts = &default_opts;
  564. if (argc < 1) {
  565. fprintf(stderr, "## Error: variable name missing\n");
  566. errno = EINVAL;
  567. return -1;
  568. }
  569. if (fw_env_open(opts)) {
  570. fprintf(stderr, "Error: environment not initialized\n");
  571. return -1;
  572. }
  573. name = argv[0];
  574. valv = argv + 1;
  575. valc = argc - 1;
  576. if (env_flags_validate_env_set_params(name, valv, valc) < 0) {
  577. fw_env_close(opts);
  578. return -1;
  579. }
  580. len = 0;
  581. for (i = 0; i < valc; ++i) {
  582. char *val = valv[i];
  583. size_t val_len = strlen(val);
  584. if (value)
  585. value[len - 1] = ' ';
  586. oldval = value;
  587. value = realloc(value, len + val_len + 1);
  588. if (!value) {
  589. fprintf(stderr,
  590. "Cannot malloc %zu bytes: %s\n",
  591. len, strerror(errno));
  592. free(oldval);
  593. return -1;
  594. }
  595. memcpy(value + len, val, val_len);
  596. len += val_len;
  597. value[len++] = '\0';
  598. }
  599. fw_env_write(name, value);
  600. free(value);
  601. ret = fw_env_flush(opts);
  602. fw_env_close(opts);
  603. return ret;
  604. }
  605. /*
  606. * Parse a file and configure the u-boot variables.
  607. * The script file has a very simple format, as follows:
  608. *
  609. * Each line has a couple with name, value:
  610. * <white spaces>variable_name<white spaces>variable_value
  611. *
  612. * Both variable_name and variable_value are interpreted as strings.
  613. * Any character after <white spaces> and before ending \r\n is interpreted
  614. * as variable's value (no comment allowed on these lines !)
  615. *
  616. * Comments are allowed if the first character in the line is #
  617. *
  618. * Returns -1 and sets errno error codes:
  619. * 0 - OK
  620. * -1 - Error
  621. */
  622. int fw_parse_script(char *fname, struct env_opts *opts)
  623. {
  624. FILE *fp;
  625. char dump[1024]; /* Maximum line length in the file */
  626. char *name;
  627. char *val;
  628. int lineno = 0;
  629. int len;
  630. int ret = 0;
  631. if (!opts)
  632. opts = &default_opts;
  633. if (fw_env_open(opts)) {
  634. fprintf(stderr, "Error: environment not initialized\n");
  635. return -1;
  636. }
  637. if (strcmp(fname, "-") == 0)
  638. fp = stdin;
  639. else {
  640. fp = fopen(fname, "r");
  641. if (fp == NULL) {
  642. fprintf(stderr, "I cannot open %s for reading\n",
  643. fname);
  644. return -1;
  645. }
  646. }
  647. while (fgets(dump, sizeof(dump), fp)) {
  648. lineno++;
  649. len = strlen(dump);
  650. /*
  651. * Read a whole line from the file. If the line is too long
  652. * or is not terminated, reports an error and exit.
  653. */
  654. if (dump[len - 1] != '\n') {
  655. fprintf(stderr,
  656. "Line %d not corrected terminated or too long\n",
  657. lineno);
  658. ret = -1;
  659. break;
  660. }
  661. /* Drop ending line feed / carriage return */
  662. dump[--len] = '\0';
  663. if (len && dump[len - 1] == '\r')
  664. dump[--len] = '\0';
  665. /* Skip comment or empty lines */
  666. if (len == 0 || dump[0] == '#')
  667. continue;
  668. /*
  669. * Search for variable's name,
  670. * remove leading whitespaces
  671. */
  672. name = skip_blanks(dump);
  673. if (!name)
  674. continue;
  675. /* The first white space is the end of variable name */
  676. val = skip_chars(name);
  677. len = strlen(name);
  678. if (val) {
  679. *val++ = '\0';
  680. if ((val - name) < len)
  681. val = skip_blanks(val);
  682. else
  683. val = NULL;
  684. }
  685. #ifdef DEBUG
  686. fprintf(stderr, "Setting %s : %s\n",
  687. name, val ? val : " removed");
  688. #endif
  689. if (env_flags_validate_type(name, val) < 0) {
  690. ret = -1;
  691. break;
  692. }
  693. /*
  694. * If there is an error setting a variable,
  695. * try to save the environment and returns an error
  696. */
  697. if (fw_env_write(name, val)) {
  698. fprintf(stderr,
  699. "fw_env_write returns with error : %s\n",
  700. strerror(errno));
  701. ret = -1;
  702. break;
  703. }
  704. }
  705. /* Close file if not stdin */
  706. if (strcmp(fname, "-") != 0)
  707. fclose(fp);
  708. ret |= fw_env_flush(opts);
  709. fw_env_close(opts);
  710. return ret;
  711. }
  712. /**
  713. * environment_end() - compute offset of first byte right after environemnt
  714. * @dev - index of enviroment buffer
  715. * Return:
  716. * device offset of first byte right after environemnt
  717. */
  718. off_t environment_end(int dev)
  719. {
  720. /* environment is block aligned */
  721. return DEVOFFSET(dev) + ENVSECTORS(dev) * DEVESIZE(dev);
  722. }
  723. /*
  724. * Test for bad block on NAND, just returns 0 on NOR, on NAND:
  725. * 0 - block is good
  726. * > 0 - block is bad
  727. * < 0 - failed to test
  728. */
  729. static int flash_bad_block(int fd, uint8_t mtd_type, loff_t blockstart)
  730. {
  731. if (mtd_type == MTD_NANDFLASH) {
  732. int badblock = ioctl(fd, MEMGETBADBLOCK, &blockstart);
  733. if (badblock < 0) {
  734. perror ("Cannot read bad block mark");
  735. return badblock;
  736. }
  737. if (badblock) {
  738. #ifdef DEBUG
  739. fprintf (stderr, "Bad block at 0x%llx, skipping\n",
  740. (unsigned long long)blockstart);
  741. #endif
  742. return badblock;
  743. }
  744. }
  745. return 0;
  746. }
  747. /*
  748. * Read data from flash at an offset into a provided buffer. On NAND it skips
  749. * bad blocks but makes sure it stays within ENVSECTORS (dev) starting from
  750. * the DEVOFFSET (dev) block. On NOR the loop is only run once.
  751. */
  752. static int flash_read_buf (int dev, int fd, void *buf, size_t count,
  753. off_t offset)
  754. {
  755. size_t blocklen; /* erase / write length - one block on NAND,
  756. 0 on NOR */
  757. size_t processed = 0; /* progress counter */
  758. size_t readlen = count; /* current read length */
  759. off_t block_seek; /* offset inside the current block to the start
  760. of the data */
  761. loff_t blockstart; /* running start of the current block -
  762. MEMGETBADBLOCK needs 64 bits */
  763. int rc;
  764. blockstart = (offset / DEVESIZE (dev)) * DEVESIZE (dev);
  765. /* Offset inside a block */
  766. block_seek = offset - blockstart;
  767. if (DEVTYPE(dev) == MTD_NANDFLASH) {
  768. /*
  769. * NAND: calculate which blocks we are reading. We have
  770. * to read one block at a time to skip bad blocks.
  771. */
  772. blocklen = DEVESIZE (dev);
  773. /* Limit to one block for the first read */
  774. if (readlen > blocklen - block_seek)
  775. readlen = blocklen - block_seek;
  776. } else {
  777. blocklen = 0;
  778. }
  779. /* This only runs once on NOR flash */
  780. while (processed < count) {
  781. rc = flash_bad_block(fd, DEVTYPE(dev), blockstart);
  782. if (rc < 0) /* block test failed */
  783. return -1;
  784. if (blockstart + block_seek + readlen > environment_end(dev)) {
  785. /* End of range is reached */
  786. fprintf (stderr,
  787. "Too few good blocks within range\n");
  788. return -1;
  789. }
  790. if (rc) { /* block is bad */
  791. blockstart += blocklen;
  792. continue;
  793. }
  794. /*
  795. * If a block is bad, we retry in the next block at the same
  796. * offset - see env/nand.c::writeenv()
  797. */
  798. lseek (fd, blockstart + block_seek, SEEK_SET);
  799. rc = read (fd, buf + processed, readlen);
  800. if (rc != readlen) {
  801. fprintf (stderr, "Read error on %s: %s\n",
  802. DEVNAME (dev), strerror (errno));
  803. return -1;
  804. }
  805. #ifdef DEBUG
  806. fprintf(stderr, "Read 0x%x bytes at 0x%llx on %s\n",
  807. rc, (unsigned long long) blockstart + block_seek,
  808. DEVNAME(dev));
  809. #endif
  810. processed += readlen;
  811. readlen = min (blocklen, count - processed);
  812. block_seek = 0;
  813. blockstart += blocklen;
  814. }
  815. return processed;
  816. }
  817. /*
  818. * Write count bytes from begin of environment, but stay within
  819. * ENVSECTORS(dev) sectors of
  820. * DEVOFFSET (dev). Similar to the read case above, on NOR and dataflash we
  821. * erase and write the whole data at once.
  822. */
  823. static int flash_write_buf(int dev, int fd, void *buf, size_t count)
  824. {
  825. void *data;
  826. struct erase_info_user erase;
  827. size_t blocklen; /* length of NAND block / NOR erase sector */
  828. size_t erase_len; /* whole area that can be erased - may include
  829. bad blocks */
  830. size_t erasesize; /* erase / write length - one block on NAND,
  831. whole area on NOR */
  832. size_t processed = 0; /* progress counter */
  833. size_t write_total; /* total size to actually write - excluding
  834. bad blocks */
  835. off_t erase_offset; /* offset to the first erase block (aligned)
  836. below offset */
  837. off_t block_seek; /* offset inside the erase block to the start
  838. of the data */
  839. loff_t blockstart; /* running start of the current block -
  840. MEMGETBADBLOCK needs 64 bits */
  841. int rc;
  842. /*
  843. * For mtd devices only offset and size of the environment do matter
  844. */
  845. if (DEVTYPE(dev) == MTD_ABSENT) {
  846. blocklen = count;
  847. erase_len = blocklen;
  848. blockstart = DEVOFFSET(dev);
  849. block_seek = 0;
  850. write_total = blocklen;
  851. } else {
  852. blocklen = DEVESIZE(dev);
  853. erase_offset = DEVOFFSET(dev);
  854. /* Maximum area we may use */
  855. erase_len = environment_end(dev) - erase_offset;
  856. blockstart = erase_offset;
  857. /* Offset inside a block */
  858. block_seek = DEVOFFSET(dev) - erase_offset;
  859. /*
  860. * Data size we actually write: from the start of the block
  861. * to the start of the data, then count bytes of data, and
  862. * to the end of the block
  863. */
  864. write_total = ((block_seek + count + blocklen - 1) /
  865. blocklen) * blocklen;
  866. }
  867. /*
  868. * Support data anywhere within erase sectors: read out the complete
  869. * area to be erased, replace the environment image, write the whole
  870. * block back again.
  871. */
  872. if (write_total > count) {
  873. data = malloc (erase_len);
  874. if (!data) {
  875. fprintf (stderr,
  876. "Cannot malloc %zu bytes: %s\n",
  877. erase_len, strerror (errno));
  878. return -1;
  879. }
  880. rc = flash_read_buf(dev, fd, data, write_total, erase_offset);
  881. if (write_total != rc)
  882. return -1;
  883. #ifdef DEBUG
  884. fprintf(stderr, "Preserving data ");
  885. if (block_seek != 0)
  886. fprintf(stderr, "0x%x - 0x%lx", 0, block_seek - 1);
  887. if (block_seek + count != write_total) {
  888. if (block_seek != 0)
  889. fprintf(stderr, " and ");
  890. fprintf(stderr, "0x%lx - 0x%lx",
  891. (unsigned long) block_seek + count,
  892. (unsigned long) write_total - 1);
  893. }
  894. fprintf(stderr, "\n");
  895. #endif
  896. /* Overwrite the old environment */
  897. memcpy (data + block_seek, buf, count);
  898. } else {
  899. /*
  900. * We get here, iff offset is block-aligned and count is a
  901. * multiple of blocklen - see write_total calculation above
  902. */
  903. data = buf;
  904. }
  905. if (DEVTYPE(dev) == MTD_NANDFLASH) {
  906. /*
  907. * NAND: calculate which blocks we are writing. We have
  908. * to write one block at a time to skip bad blocks.
  909. */
  910. erasesize = blocklen;
  911. } else {
  912. erasesize = erase_len;
  913. }
  914. erase.length = erasesize;
  915. /* This only runs once on NOR flash and SPI-dataflash */
  916. while (processed < write_total) {
  917. rc = flash_bad_block(fd, DEVTYPE(dev), blockstart);
  918. if (rc < 0) /* block test failed */
  919. return rc;
  920. if (blockstart + erasesize > environment_end(dev)) {
  921. fprintf (stderr, "End of range reached, aborting\n");
  922. return -1;
  923. }
  924. if (rc) { /* block is bad */
  925. blockstart += blocklen;
  926. continue;
  927. }
  928. if (DEVTYPE(dev) != MTD_ABSENT) {
  929. erase.start = blockstart;
  930. ioctl(fd, MEMUNLOCK, &erase);
  931. /* These do not need an explicit erase cycle */
  932. if (DEVTYPE(dev) != MTD_DATAFLASH)
  933. if (ioctl(fd, MEMERASE, &erase) != 0) {
  934. fprintf(stderr,
  935. "MTD erase error on %s: %s\n",
  936. DEVNAME(dev), strerror(errno));
  937. return -1;
  938. }
  939. }
  940. if (lseek (fd, blockstart, SEEK_SET) == -1) {
  941. fprintf (stderr,
  942. "Seek error on %s: %s\n",
  943. DEVNAME (dev), strerror (errno));
  944. return -1;
  945. }
  946. #ifdef DEBUG
  947. fprintf(stderr, "Write 0x%llx bytes at 0x%llx\n",
  948. (unsigned long long) erasesize,
  949. (unsigned long long) blockstart);
  950. #endif
  951. if (write (fd, data + processed, erasesize) != erasesize) {
  952. fprintf (stderr, "Write error on %s: %s\n",
  953. DEVNAME (dev), strerror (errno));
  954. return -1;
  955. }
  956. if (DEVTYPE(dev) != MTD_ABSENT)
  957. ioctl(fd, MEMLOCK, &erase);
  958. processed += erasesize;
  959. block_seek = 0;
  960. blockstart += erasesize;
  961. }
  962. if (write_total > count)
  963. free (data);
  964. return processed;
  965. }
  966. /*
  967. * Set obsolete flag at offset - NOR flash only
  968. */
  969. static int flash_flag_obsolete (int dev, int fd, off_t offset)
  970. {
  971. int rc;
  972. struct erase_info_user erase;
  973. erase.start = DEVOFFSET (dev);
  974. erase.length = DEVESIZE (dev);
  975. /* This relies on the fact, that obsolete_flag == 0 */
  976. rc = lseek (fd, offset, SEEK_SET);
  977. if (rc < 0) {
  978. fprintf (stderr, "Cannot seek to set the flag on %s \n",
  979. DEVNAME (dev));
  980. return rc;
  981. }
  982. ioctl (fd, MEMUNLOCK, &erase);
  983. rc = write (fd, &obsolete_flag, sizeof (obsolete_flag));
  984. ioctl (fd, MEMLOCK, &erase);
  985. if (rc < 0)
  986. perror ("Could not set obsolete flag");
  987. return rc;
  988. }
  989. static int flash_write (int fd_current, int fd_target, int dev_target)
  990. {
  991. int rc;
  992. switch (environment.flag_scheme) {
  993. case FLAG_NONE:
  994. break;
  995. case FLAG_INCREMENTAL:
  996. (*environment.flags)++;
  997. break;
  998. case FLAG_BOOLEAN:
  999. *environment.flags = active_flag;
  1000. break;
  1001. default:
  1002. fprintf (stderr, "Unimplemented flash scheme %u \n",
  1003. environment.flag_scheme);
  1004. return -1;
  1005. }
  1006. #ifdef DEBUG
  1007. fprintf(stderr, "Writing new environment at 0x%llx on %s\n",
  1008. DEVOFFSET (dev_target), DEVNAME (dev_target));
  1009. #endif
  1010. if (IS_UBI(dev_target)) {
  1011. if (ubi_update_start(fd_target, CUR_ENVSIZE) < 0)
  1012. return 0;
  1013. return ubi_write(fd_target, environment.image, CUR_ENVSIZE);
  1014. }
  1015. rc = flash_write_buf(dev_target, fd_target, environment.image,
  1016. CUR_ENVSIZE);
  1017. if (rc < 0)
  1018. return rc;
  1019. if (environment.flag_scheme == FLAG_BOOLEAN) {
  1020. /* Have to set obsolete flag */
  1021. off_t offset = DEVOFFSET (dev_current) +
  1022. offsetof (struct env_image_redundant, flags);
  1023. #ifdef DEBUG
  1024. fprintf(stderr,
  1025. "Setting obsolete flag in environment at 0x%llx on %s\n",
  1026. DEVOFFSET (dev_current), DEVNAME (dev_current));
  1027. #endif
  1028. flash_flag_obsolete (dev_current, fd_current, offset);
  1029. }
  1030. return 0;
  1031. }
  1032. static int flash_read (int fd)
  1033. {
  1034. int rc;
  1035. if (IS_UBI(dev_current)) {
  1036. DEVTYPE(dev_current) = MTD_ABSENT;
  1037. return ubi_read(fd, environment.image, CUR_ENVSIZE);
  1038. }
  1039. rc = flash_read_buf(dev_current, fd, environment.image, CUR_ENVSIZE,
  1040. DEVOFFSET(dev_current));
  1041. if (rc != CUR_ENVSIZE)
  1042. return -1;
  1043. return 0;
  1044. }
  1045. static int flash_io (int mode)
  1046. {
  1047. int fd_current, fd_target, rc, dev_target;
  1048. /* dev_current: fd_current, erase_current */
  1049. fd_current = open (DEVNAME (dev_current), mode);
  1050. if (fd_current < 0) {
  1051. fprintf (stderr,
  1052. "Can't open %s: %s\n",
  1053. DEVNAME (dev_current), strerror (errno));
  1054. return -1;
  1055. }
  1056. if (mode == O_RDWR) {
  1057. if (HaveRedundEnv) {
  1058. /* switch to next partition for writing */
  1059. dev_target = !dev_current;
  1060. /* dev_target: fd_target, erase_target */
  1061. fd_target = open (DEVNAME (dev_target), mode);
  1062. if (fd_target < 0) {
  1063. fprintf (stderr,
  1064. "Can't open %s: %s\n",
  1065. DEVNAME (dev_target),
  1066. strerror (errno));
  1067. rc = -1;
  1068. goto exit;
  1069. }
  1070. } else {
  1071. dev_target = dev_current;
  1072. fd_target = fd_current;
  1073. }
  1074. rc = flash_write (fd_current, fd_target, dev_target);
  1075. if (fsync(fd_current) &&
  1076. !(errno == EINVAL || errno == EROFS)) {
  1077. fprintf (stderr,
  1078. "fsync failed on %s: %s\n",
  1079. DEVNAME (dev_current), strerror (errno));
  1080. }
  1081. if (HaveRedundEnv) {
  1082. if (fsync(fd_target) &&
  1083. !(errno == EINVAL || errno == EROFS)) {
  1084. fprintf (stderr,
  1085. "fsync failed on %s: %s\n",
  1086. DEVNAME (dev_current), strerror (errno));
  1087. }
  1088. if (close (fd_target)) {
  1089. fprintf (stderr,
  1090. "I/O error on %s: %s\n",
  1091. DEVNAME (dev_target),
  1092. strerror (errno));
  1093. rc = -1;
  1094. }
  1095. }
  1096. } else {
  1097. rc = flash_read (fd_current);
  1098. }
  1099. exit:
  1100. if (close (fd_current)) {
  1101. fprintf (stderr,
  1102. "I/O error on %s: %s\n",
  1103. DEVNAME (dev_current), strerror (errno));
  1104. return -1;
  1105. }
  1106. return rc;
  1107. }
  1108. /*
  1109. * Prevent confusion if running from erased flash memory
  1110. */
  1111. int fw_env_open(struct env_opts *opts)
  1112. {
  1113. int crc0, crc0_ok;
  1114. unsigned char flag0;
  1115. void *addr0 = NULL;
  1116. int crc1, crc1_ok;
  1117. unsigned char flag1;
  1118. void *addr1 = NULL;
  1119. int ret;
  1120. struct env_image_single *single;
  1121. struct env_image_redundant *redundant;
  1122. if (!opts)
  1123. opts = &default_opts;
  1124. if (parse_config(opts)) /* should fill envdevices */
  1125. return -EINVAL;
  1126. addr0 = calloc(1, CUR_ENVSIZE);
  1127. if (addr0 == NULL) {
  1128. fprintf(stderr,
  1129. "Not enough memory for environment (%ld bytes)\n",
  1130. CUR_ENVSIZE);
  1131. ret = -ENOMEM;
  1132. goto open_cleanup;
  1133. }
  1134. /* read environment from FLASH to local buffer */
  1135. environment.image = addr0;
  1136. if (HaveRedundEnv) {
  1137. redundant = addr0;
  1138. environment.crc = &redundant->crc;
  1139. environment.flags = &redundant->flags;
  1140. environment.data = redundant->data;
  1141. } else {
  1142. single = addr0;
  1143. environment.crc = &single->crc;
  1144. environment.flags = NULL;
  1145. environment.data = single->data;
  1146. }
  1147. dev_current = 0;
  1148. if (flash_io(O_RDONLY)) {
  1149. ret = -EIO;
  1150. goto open_cleanup;
  1151. }
  1152. crc0 = crc32 (0, (uint8_t *) environment.data, ENV_SIZE);
  1153. crc0_ok = (crc0 == *environment.crc);
  1154. if (!HaveRedundEnv) {
  1155. if (!crc0_ok) {
  1156. fprintf (stderr,
  1157. "Warning: Bad CRC, using default environment\n");
  1158. memcpy(environment.data, default_environment, sizeof default_environment);
  1159. }
  1160. } else {
  1161. flag0 = *environment.flags;
  1162. dev_current = 1;
  1163. addr1 = calloc(1, CUR_ENVSIZE);
  1164. if (addr1 == NULL) {
  1165. fprintf(stderr,
  1166. "Not enough memory for environment (%ld bytes)\n",
  1167. CUR_ENVSIZE);
  1168. ret = -ENOMEM;
  1169. goto open_cleanup;
  1170. }
  1171. redundant = addr1;
  1172. /*
  1173. * have to set environment.image for flash_read(), careful -
  1174. * other pointers in environment still point inside addr0
  1175. */
  1176. environment.image = addr1;
  1177. if (flash_io(O_RDONLY)) {
  1178. ret = -EIO;
  1179. goto open_cleanup;
  1180. }
  1181. /* Check flag scheme compatibility */
  1182. if (DEVTYPE(dev_current) == MTD_NORFLASH &&
  1183. DEVTYPE(!dev_current) == MTD_NORFLASH) {
  1184. environment.flag_scheme = FLAG_BOOLEAN;
  1185. } else if (DEVTYPE(dev_current) == MTD_NANDFLASH &&
  1186. DEVTYPE(!dev_current) == MTD_NANDFLASH) {
  1187. environment.flag_scheme = FLAG_INCREMENTAL;
  1188. } else if (DEVTYPE(dev_current) == MTD_DATAFLASH &&
  1189. DEVTYPE(!dev_current) == MTD_DATAFLASH) {
  1190. environment.flag_scheme = FLAG_BOOLEAN;
  1191. } else if (DEVTYPE(dev_current) == MTD_UBIVOLUME &&
  1192. DEVTYPE(!dev_current) == MTD_UBIVOLUME) {
  1193. environment.flag_scheme = FLAG_INCREMENTAL;
  1194. } else if (DEVTYPE(dev_current) == MTD_ABSENT &&
  1195. DEVTYPE(!dev_current) == MTD_ABSENT &&
  1196. IS_UBI(dev_current) == IS_UBI(!dev_current)) {
  1197. environment.flag_scheme = FLAG_INCREMENTAL;
  1198. } else {
  1199. fprintf (stderr, "Incompatible flash types!\n");
  1200. ret = -EINVAL;
  1201. goto open_cleanup;
  1202. }
  1203. crc1 = crc32 (0, (uint8_t *) redundant->data, ENV_SIZE);
  1204. crc1_ok = (crc1 == redundant->crc);
  1205. flag1 = redundant->flags;
  1206. if (crc0_ok && !crc1_ok) {
  1207. dev_current = 0;
  1208. } else if (!crc0_ok && crc1_ok) {
  1209. dev_current = 1;
  1210. } else if (!crc0_ok && !crc1_ok) {
  1211. fprintf (stderr,
  1212. "Warning: Bad CRC, using default environment\n");
  1213. memcpy (environment.data, default_environment,
  1214. sizeof default_environment);
  1215. dev_current = 0;
  1216. } else {
  1217. switch (environment.flag_scheme) {
  1218. case FLAG_BOOLEAN:
  1219. if (flag0 == active_flag &&
  1220. flag1 == obsolete_flag) {
  1221. dev_current = 0;
  1222. } else if (flag0 == obsolete_flag &&
  1223. flag1 == active_flag) {
  1224. dev_current = 1;
  1225. } else if (flag0 == flag1) {
  1226. dev_current = 0;
  1227. } else if (flag0 == 0xFF) {
  1228. dev_current = 0;
  1229. } else if (flag1 == 0xFF) {
  1230. dev_current = 1;
  1231. } else {
  1232. dev_current = 0;
  1233. }
  1234. break;
  1235. case FLAG_INCREMENTAL:
  1236. if (flag0 == 255 && flag1 == 0)
  1237. dev_current = 1;
  1238. else if ((flag1 == 255 && flag0 == 0) ||
  1239. flag0 >= flag1)
  1240. dev_current = 0;
  1241. else /* flag1 > flag0 */
  1242. dev_current = 1;
  1243. break;
  1244. default:
  1245. fprintf (stderr, "Unknown flag scheme %u \n",
  1246. environment.flag_scheme);
  1247. return -1;
  1248. }
  1249. }
  1250. /*
  1251. * If we are reading, we don't need the flag and the CRC any
  1252. * more, if we are writing, we will re-calculate CRC and update
  1253. * flags before writing out
  1254. */
  1255. if (dev_current) {
  1256. environment.image = addr1;
  1257. environment.crc = &redundant->crc;
  1258. environment.flags = &redundant->flags;
  1259. environment.data = redundant->data;
  1260. free (addr0);
  1261. } else {
  1262. environment.image = addr0;
  1263. /* Other pointers are already set */
  1264. free (addr1);
  1265. }
  1266. #ifdef DEBUG
  1267. fprintf(stderr, "Selected env in %s\n", DEVNAME(dev_current));
  1268. #endif
  1269. }
  1270. return 0;
  1271. open_cleanup:
  1272. if (addr0)
  1273. free(addr0);
  1274. if (addr1)
  1275. free(addr0);
  1276. return ret;
  1277. }
  1278. /*
  1279. * Simply free allocated buffer with environment
  1280. */
  1281. int fw_env_close(struct env_opts *opts)
  1282. {
  1283. if (environment.image)
  1284. free(environment.image);
  1285. environment.image = NULL;
  1286. return 0;
  1287. }
  1288. static int check_device_config(int dev)
  1289. {
  1290. struct stat st;
  1291. int32_t lnum = 0;
  1292. int fd, rc = 0;
  1293. /* Fills in IS_UBI(), converts DEVNAME() with ubi volume name */
  1294. ubi_check_dev(dev);
  1295. fd = open(DEVNAME(dev), O_RDONLY);
  1296. if (fd < 0) {
  1297. fprintf(stderr,
  1298. "Cannot open %s: %s\n",
  1299. DEVNAME(dev), strerror(errno));
  1300. return -1;
  1301. }
  1302. rc = fstat(fd, &st);
  1303. if (rc < 0) {
  1304. fprintf(stderr, "Cannot stat the file %s\n",
  1305. DEVNAME(dev));
  1306. goto err;
  1307. }
  1308. if (IS_UBI(dev)) {
  1309. rc = ioctl(fd, UBI_IOCEBISMAP, &lnum);
  1310. if (rc < 0) {
  1311. fprintf(stderr, "Cannot get UBI information for %s\n",
  1312. DEVNAME(dev));
  1313. goto err;
  1314. }
  1315. } else if (S_ISCHR(st.st_mode)) {
  1316. struct mtd_info_user mtdinfo;
  1317. rc = ioctl(fd, MEMGETINFO, &mtdinfo);
  1318. if (rc < 0) {
  1319. fprintf(stderr, "Cannot get MTD information for %s\n",
  1320. DEVNAME(dev));
  1321. goto err;
  1322. }
  1323. if (mtdinfo.type != MTD_NORFLASH &&
  1324. mtdinfo.type != MTD_NANDFLASH &&
  1325. mtdinfo.type != MTD_DATAFLASH &&
  1326. mtdinfo.type != MTD_UBIVOLUME) {
  1327. fprintf(stderr, "Unsupported flash type %u on %s\n",
  1328. mtdinfo.type, DEVNAME(dev));
  1329. goto err;
  1330. }
  1331. DEVTYPE(dev) = mtdinfo.type;
  1332. if (DEVESIZE(dev) == 0)
  1333. /* Assume the erase size is the same as the env-size */
  1334. DEVESIZE(dev) = ENVSIZE(dev);
  1335. } else {
  1336. uint64_t size;
  1337. DEVTYPE(dev) = MTD_ABSENT;
  1338. if (DEVESIZE(dev) == 0)
  1339. /* Assume the erase size to be 512 bytes */
  1340. DEVESIZE(dev) = 0x200;
  1341. /*
  1342. * Check for negative offsets, treat it as backwards offset
  1343. * from the end of the block device
  1344. */
  1345. if (DEVOFFSET(dev) < 0) {
  1346. rc = ioctl(fd, BLKGETSIZE64, &size);
  1347. if (rc < 0) {
  1348. fprintf(stderr, "Could not get block device size on %s\n",
  1349. DEVNAME(dev));
  1350. goto err;
  1351. }
  1352. DEVOFFSET(dev) = DEVOFFSET(dev) + size;
  1353. #ifdef DEBUG
  1354. fprintf(stderr, "Calculated device offset 0x%llx on %s\n",
  1355. DEVOFFSET(dev), DEVNAME(dev));
  1356. #endif
  1357. }
  1358. }
  1359. if (ENVSECTORS(dev) == 0)
  1360. /* Assume enough sectors to cover the environment */
  1361. ENVSECTORS(dev) = DIV_ROUND_UP(ENVSIZE(dev), DEVESIZE(dev));
  1362. if (DEVOFFSET(dev) % DEVESIZE(dev) != 0) {
  1363. fprintf(stderr, "Environment does not start on (erase) block boundary\n");
  1364. errno = EINVAL;
  1365. return -1;
  1366. }
  1367. if (ENVSIZE(dev) > ENVSECTORS(dev) * DEVESIZE(dev)) {
  1368. fprintf(stderr, "Environment does not fit into available sectors\n");
  1369. errno = EINVAL;
  1370. return -1;
  1371. }
  1372. err:
  1373. close(fd);
  1374. return rc;
  1375. }
  1376. static int parse_config(struct env_opts *opts)
  1377. {
  1378. int rc;
  1379. if (!opts)
  1380. opts = &default_opts;
  1381. #if defined(CONFIG_FILE)
  1382. /* Fills in DEVNAME(), ENVSIZE(), DEVESIZE(). Or don't. */
  1383. if (get_config(opts->config_file)) {
  1384. fprintf(stderr, "Cannot parse config file '%s': %m\n",
  1385. opts->config_file);
  1386. return -1;
  1387. }
  1388. #else
  1389. DEVNAME (0) = DEVICE1_NAME;
  1390. DEVOFFSET (0) = DEVICE1_OFFSET;
  1391. ENVSIZE (0) = ENV1_SIZE;
  1392. /* Set defaults for DEVESIZE, ENVSECTORS later once we
  1393. * know DEVTYPE
  1394. */
  1395. #ifdef DEVICE1_ESIZE
  1396. DEVESIZE (0) = DEVICE1_ESIZE;
  1397. #endif
  1398. #ifdef DEVICE1_ENVSECTORS
  1399. ENVSECTORS (0) = DEVICE1_ENVSECTORS;
  1400. #endif
  1401. #ifdef HAVE_REDUND
  1402. DEVNAME (1) = DEVICE2_NAME;
  1403. DEVOFFSET (1) = DEVICE2_OFFSET;
  1404. ENVSIZE (1) = ENV2_SIZE;
  1405. /* Set defaults for DEVESIZE, ENVSECTORS later once we
  1406. * know DEVTYPE
  1407. */
  1408. #ifdef DEVICE2_ESIZE
  1409. DEVESIZE (1) = DEVICE2_ESIZE;
  1410. #endif
  1411. #ifdef DEVICE2_ENVSECTORS
  1412. ENVSECTORS (1) = DEVICE2_ENVSECTORS;
  1413. #endif
  1414. HaveRedundEnv = 1;
  1415. #endif
  1416. #endif
  1417. rc = check_device_config(0);
  1418. if (rc < 0)
  1419. return rc;
  1420. if (HaveRedundEnv) {
  1421. rc = check_device_config(1);
  1422. if (rc < 0)
  1423. return rc;
  1424. if (ENVSIZE(0) != ENVSIZE(1)) {
  1425. fprintf(stderr,
  1426. "Redundant environments have unequal size");
  1427. return -1;
  1428. }
  1429. }
  1430. usable_envsize = CUR_ENVSIZE - sizeof(uint32_t);
  1431. if (HaveRedundEnv)
  1432. usable_envsize -= sizeof(char);
  1433. return 0;
  1434. }
  1435. #if defined(CONFIG_FILE)
  1436. static int get_config (char *fname)
  1437. {
  1438. FILE *fp;
  1439. int i = 0;
  1440. int rc;
  1441. char dump[128];
  1442. char *devname;
  1443. fp = fopen (fname, "r");
  1444. if (fp == NULL)
  1445. return -1;
  1446. while (i < 2 && fgets (dump, sizeof (dump), fp)) {
  1447. /* Skip incomplete conversions and comment strings */
  1448. if (dump[0] == '#')
  1449. continue;
  1450. rc = sscanf(dump, "%ms %lli %lx %lx %lx",
  1451. &devname,
  1452. &DEVOFFSET(i),
  1453. &ENVSIZE(i),
  1454. &DEVESIZE(i),
  1455. &ENVSECTORS(i));
  1456. if (rc < 3)
  1457. continue;
  1458. DEVNAME(i) = devname;
  1459. /* Set defaults for DEVESIZE, ENVSECTORS later once we
  1460. * know DEVTYPE
  1461. */
  1462. i++;
  1463. }
  1464. fclose (fp);
  1465. HaveRedundEnv = i - 1;
  1466. if (!i) { /* No valid entries found */
  1467. errno = EINVAL;
  1468. return -1;
  1469. } else
  1470. return 0;
  1471. }
  1472. #endif