fs/fs.c

   1 /*
   2  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #include <config.h>
  18 #include <errno.h>
  19 #include <common.h>
  20 #include <part.h>
  21 #include <ext4fs.h>
  22 #include <fat.h>
  23 #include <fs.h>
  24 #include <sandboxfs.h>
  25 #include <asm/io.h>
  26 #include <div64.h>
  27 #include <linux/math64.h>
  28
  29 DECLARE_GLOBAL_DATA_PTR;
  30
  31 static block_dev_desc_t *fs_dev_desc;
  32 static disk_partition_t fs_partition;
  33 static int fs_type = FS_TYPE_ANY;
  34
  35 static inline int fs_probe_unsupported(block_dev_desc_t *fs_dev_desc,
  36                                       disk_partition_t *fs_partition)
  37 {
  38         printf("** Unrecognized filesystem type **\n");
  39         return -1;
  40 }
  41
  42 static inline int fs_ls_unsupported(const char *dirname)
  43 {
  44         return -1;
  45 }
  46
  47 static inline int fs_exists_unsupported(const char *filename)
  48 {
  49         return 0;
  50 }
  51
  52 static inline int fs_size_unsupported(const char *filename, loff_t *size)
  53 {
  54         return -1;
  55 }
  56
  57 static inline int fs_read_unsupported(const char *filename, void *buf,
  58                                       loff_t offset, loff_t len,
  59                                       loff_t *actread)
  60 {
  61         return -1;
  62 }
  63
  64 static inline int fs_write_unsupported(const char *filename, void *buf,
  65                                       loff_t offset, loff_t len,
  66                                       loff_t *actwrite)
  67 {
  68         return -1;
  69 }
  70
  71 static inline void fs_close_unsupported(void)
  72 {
  73 }
  74
  75 static inline int fs_uuid_unsupported(char *uuid_str)
  76 {
  77         return -1;
  78 }
  79
  80 struct fstype_info {
  81         int fstype;
  82         char *name;
  83         /*
  84          * Is it legal to pass NULL as .probe()'s  fs_dev_desc parameter? This
  85          * should be false in most cases. For "virtual" filesystems which
  86          * aren't based on a U-Boot block device (e.g. sandbox), this can be
  87          * set to true. This should also be true for the dumm entry at the end
  88          * of fstypes[], since that is essentially a "virtual" (non-existent)
  89          * filesystem.
  90          */
  91         bool null_dev_desc_ok;
  92         int (*probe)(block_dev_desc_t *fs_dev_desc,
  93                      disk_partition_t *fs_partition);
  94         int (*ls)(const char *dirname);
  95         int (*exists)(const char *filename);
  96         int (*size)(const char *filename, loff_t *size);
  97         int (*read)(const char *filename, void *buf, loff_t offset,
  98                     loff_t len, loff_t *actread);
  99         int (*write)(const char *filename, void *buf, loff_t offset,
 100                      loff_t len, loff_t *actwrite);
 101         void (*close)(void);
 102         int (*uuid)(char *uuid_str);
 103 };
 104
 105 static struct fstype_info fstypes[] = {
 106 #ifdef CONFIG_FS_FAT
 107         {
 108                 .fstype = FS_TYPE_FAT,
 109                 .name = "fat",
 110                 .null_dev_desc_ok = false,
 111                 .probe = fat_set_blk_dev,
 112                 .close = fat_close,
 113                 .ls = file_fat_ls,
 114                 .exists = fat_exists,
 115                 .size = fat_size,
 116                 .read = fat_read_file,
 117 #ifdef CONFIG_FAT_WRITE
 118                 .write = file_fat_write,
 119 #else
 120                 .write = fs_write_unsupported,
 121 #endif
 122                 .uuid = fs_uuid_unsupported,
 123         },
 124 #endif
 125 #ifdef CONFIG_FS_EXT4
 126         {
 127                 .fstype = FS_TYPE_EXT,
 128                 .name = "ext4",
 129                 .null_dev_desc_ok = false,
 130                 .probe = ext4fs_probe,
 131                 .close = ext4fs_close,
 132                 .ls = ext4fs_ls,
 133                 .exists = ext4fs_exists,
 134                 .size = ext4fs_size,
 135                 .read = ext4_read_file,
 136 #ifdef CONFIG_CMD_EXT4_WRITE
 137                 .write = ext4_write_file,
 138 #else
 139                 .write = fs_write_unsupported,
 140 #endif
 141                 .uuid = ext4fs_uuid,
 142         },
 143 #endif
 144 #ifdef CONFIG_SANDBOX
 145         {
 146                 .fstype = FS_TYPE_SANDBOX,
 147                 .name = "sandbox",
 148                 .null_dev_desc_ok = true,
 149                 .probe = sandbox_fs_set_blk_dev,
 150                 .close = sandbox_fs_close,
 151                 .ls = sandbox_fs_ls,
 152                 .exists = sandbox_fs_exists,
 153                 .size = sandbox_fs_size,
 154                 .read = fs_read_sandbox,
 155                 .write = fs_write_sandbox,
 156                 .uuid = fs_uuid_unsupported,
 157         },
 158 #endif
 159         {
 160                 .fstype = FS_TYPE_ANY,
 161                 .name = "unsupported",
 162                 .null_dev_desc_ok = true,
 163                 .probe = fs_probe_unsupported,
 164                 .close = fs_close_unsupported,
 165                 .ls = fs_ls_unsupported,
 166                 .exists = fs_exists_unsupported,
 167                 .size = fs_size_unsupported,
 168                 .read = fs_read_unsupported,
 169                 .write = fs_write_unsupported,
 170                 .uuid = fs_uuid_unsupported,
 171         },
 172 };
 173
 174 static struct fstype_info *fs_get_info(int fstype)
 175 {
 176         struct fstype_info *info;
 177         int i;
 178
 179         for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
 180                 if (fstype == info->fstype)
 181                         return info;
 182         }
 183
 184         /* Return the 'unsupported' sentinel */
 185         return info;
 186 }
 187
 188 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
 189 {
 190         struct fstype_info *info;
 191         int part, i;
 192 #ifdef CONFIG_NEEDS_MANUAL_RELOC
 193         static int relocated;
 194
 195         if (!relocated) {
 196                 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes);
 197                                 i++, info++) {
 198                         info->name += gd->reloc_off;
 199                         info->probe += gd->reloc_off;
 200                         info->close += gd->reloc_off;
 201                         info->ls += gd->reloc_off;
 202                         info->read += gd->reloc_off;
 203                         info->write += gd->reloc_off;
 204                 }
 205                 relocated = 1;
 206         }
 207 #endif
 208
 209         part = get_device_and_partition(ifname, dev_part_str, &fs_dev_desc,
 210                                         &fs_partition, 1);
 211         if (part < 0)
 212                 return -1;
 213
 214         for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
 215                 if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
 216                                 fstype != info->fstype)
 217                         continue;
 218
 219                 if (!fs_dev_desc && !info->null_dev_desc_ok)
 220                         continue;
 221
 222                 if (!info->probe(fs_dev_desc, &fs_partition)) {
 223                         fs_type = info->fstype;
 224                         return 0;
 225                 }
 226         }
 227
 228         return -1;
 229 }
 230
 231 static void fs_close(void)
 232 {
 233         struct fstype_info *info = fs_get_info(fs_type);
 234
 235         info->close();
 236
 237         fs_type = FS_TYPE_ANY;
 238 }
 239
 240 int fs_uuid(char *uuid_str)
 241 {
 242         struct fstype_info *info = fs_get_info(fs_type);
 243
 244         return info->uuid(uuid_str);
 245 }
 246
 247 int fs_ls(const char *dirname)
 248 {
 249         int ret;
 250
 251         struct fstype_info *info = fs_get_info(fs_type);
 252
 253         ret = info->ls(dirname);
 254
 255         fs_type = FS_TYPE_ANY;
 256         fs_close();
 257
 258         return ret;
 259 }
 260
 261 int fs_exists(const char *filename)
 262 {
 263         int ret;
 264
 265         struct fstype_info *info = fs_get_info(fs_type);
 266
 267         ret = info->exists(filename);
 268
 269         fs_close();
 270
 271         return ret;
 272 }
 273
 274 int fs_size(const char *filename, loff_t *size)
 275 {
 276         int ret;
 277
 278         struct fstype_info *info = fs_get_info(fs_type);
 279
 280         ret = info->size(filename, size);
 281
 282         fs_close();
 283
 284         return ret;
 285 }
 286
 287 int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
 288             loff_t *actread)
 289 {
 290         struct fstype_info *info = fs_get_info(fs_type);
 291         void *buf;
 292         int ret;
 293
 294         /*
 295          * We don't actually know how many bytes are being read, since len==0
 296          * means read the whole file.
 297          */
 298         buf = map_sysmem(addr, len);
 299         ret = info->read(filename, buf, offset, len, actread);
 300         unmap_sysmem(buf);
 301
 302         /* If we requested a specific number of bytes, check we got it */
 303         if (ret == 0 && len && *actread != len) {
 304                 printf("** Unable to read file %s **\n", filename);
 305                 ret = -1;
 306         }
 307         fs_close();
 308
 309         return ret;
 310 }
 311
 312 int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len,
 313              loff_t *actwrite)
 314 {
 315         struct fstype_info *info = fs_get_info(fs_type);
 316         void *buf;
 317         int ret;
 318
 319         buf = map_sysmem(addr, len);
 320         ret = info->write(filename, buf, offset, len, actwrite);
 321         unmap_sysmem(buf);
 322
 323         if (ret < 0 && len != *actwrite) {
 324                 printf("** Unable to write file %s **\n", filename);
 325                 ret = -1;
 326         }
 327         fs_close();
 328
 329         return ret;
 330 }
 331
 332 int do_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 333                 int fstype)
 334 {
 335         loff_t size;
 336
 337         if (argc != 4)
 338                 return CMD_RET_USAGE;
 339
 340         if (fs_set_blk_dev(argv[1], argv[2], fstype))
 341                 return 1;
 342
 343         if (fs_size(argv[3], &size) < 0)
 344                 return CMD_RET_FAILURE;
 345
 346         setenv_hex("filesize", size);
 347
 348         return 0;
 349 }
 350
 351 int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 352                 int fstype)
 353 {
 354         unsigned long addr;
 355         const char *addr_str;
 356         const char *filename;
 357         loff_t bytes;
 358         loff_t pos;
 359         loff_t len_read;
 360         int ret;
 361         unsigned long time;
 362         char *ep;
 363
 364         if (argc < 2)
 365                 return CMD_RET_USAGE;
 366         if (argc > 7)
 367                 return CMD_RET_USAGE;
 368
 369         if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
 370                 return 1;
 371
 372         if (argc >= 4) {
 373                 addr = simple_strtoul(argv[3], &ep, 16);
 374                 if (ep == argv[3] || *ep != '\0')
 375                         return CMD_RET_USAGE;
 376         } else {
 377                 addr_str = getenv("loadaddr");
 378                 if (addr_str != NULL)
 379                         addr = simple_strtoul(addr_str, NULL, 16);
 380                 else
 381                         addr = CONFIG_SYS_LOAD_ADDR;
 382         }
 383         if (argc >= 5) {
 384                 filename = argv[4];
 385         } else {
 386                 filename = getenv("bootfile");
 387                 if (!filename) {
 388                         puts("** No boot file defined **\n");
 389                         return 1;
 390                 }
 391         }
 392         if (argc >= 6)
 393                 bytes = simple_strtoul(argv[5], NULL, 16);
 394         else
 395                 bytes = 0;
 396         if (argc >= 7)
 397                 pos = simple_strtoul(argv[6], NULL, 16);
 398         else
 399                 pos = 0;
 400
 401         time = get_timer(0);
 402         ret = fs_read(filename, addr, pos, bytes, &len_read);
 403         time = get_timer(time);
 404         if (ret < 0)
 405                 return 1;
 406
 407         printf("%llu bytes read in %lu ms", len_read, time);
 408         if (time > 0) {
 409                 puts(" (");
 410                 print_size(div_u64(len_read, time) * 1000, "/s");
 411                 puts(")");
 412         }
 413         puts("\n");
 414
 415         setenv_hex("filesize", len_read);
 416
 417         return 0;
 418 }
 419
 420 int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 421         int fstype)
 422 {
 423         if (argc < 2)
 424                 return CMD_RET_USAGE;
 425         if (argc > 4)
 426                 return CMD_RET_USAGE;
 427
 428         if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
 429                 return 1;
 430
 431         if (fs_ls(argc >= 4 ? argv[3] : "/"))
 432                 return 1;
 433
 434         return 0;
 435 }
 436
 437 int file_exists(const char *dev_type, const char *dev_part, const char *file,
 438                 int fstype)
 439 {
 440         if (fs_set_blk_dev(dev_type, dev_part, fstype))
 441                 return 0;
 442
 443         return fs_exists(file);
 444 }
 445
 446 int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 447                 int fstype)
 448 {
 449         unsigned long addr;
 450         const char *filename;
 451         loff_t bytes;
 452         loff_t pos;
 453         loff_t len;
 454         int ret;
 455         unsigned long time;
 456
 457         if (argc < 6 || argc > 7)
 458                 return CMD_RET_USAGE;
 459
 460         if (fs_set_blk_dev(argv[1], argv[2], fstype))
 461                 return 1;
 462
 463         addr = simple_strtoul(argv[3], NULL, 16);
 464         filename = argv[4];
 465         bytes = simple_strtoul(argv[5], NULL, 16);
 466         if (argc >= 7)
 467                 pos = simple_strtoul(argv[6], NULL, 16);
 468         else
 469                 pos = 0;
 470
 471         time = get_timer(0);
 472         ret = fs_write(filename, addr, pos, bytes, &len);
 473         time = get_timer(time);
 474         if (ret < 0)
 475                 return 1;
 476
 477         printf("%llu bytes written in %lu ms", len, time);
 478         if (time > 0) {
 479                 puts(" (");
 480                 print_size(div_u64(len, time) * 1000, "/s");
 481                 puts(")");
 482         }
 483         puts("\n");
 484
 485         return 0;
 486 }
 487
 488 int do_fs_uuid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
 489                 int fstype)
 490 {
 491         int ret;
 492         char uuid[37];
 493         memset(uuid, 0, sizeof(uuid));
 494
 495         if (argc < 3 || argc > 4)
 496                 return CMD_RET_USAGE;
 497
 498         if (fs_set_blk_dev(argv[1], argv[2], fstype))
 499                 return 1;
 500
 501         ret = fs_uuid(uuid);
 502         if (ret)
 503                 return CMD_RET_FAILURE;
 504
 505         if (argc == 4)
 506                 setenv(argv[3], uuid);
 507         else
 508                 printf("%s\n", uuid);
 509
 510         return CMD_RET_SUCCESS;
 511 }
 512
 513 int do_fs_type(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 514 {
 515         struct fstype_info *info;
 516
 517         if (argc < 3 || argc > 4)
 518                 return CMD_RET_USAGE;
 519
 520         if (fs_set_blk_dev(argv[1], argv[2], FS_TYPE_ANY))
 521                 return 1;
 522
 523         info = fs_get_info(fs_type);
 524
 525         if (argc == 4)
 526                 setenv(argv[3], info->name);
 527         else
 528                 printf("%s\n", info->name);
 529
 530         return CMD_RET_SUCCESS;
 531 }
 532