f408994fc632129dcbdceca43cedf2fd14705205
[muen/linux.git] / fs / cramfs / inode.c
1 /*
2  * Compressed rom filesystem for Linux.
3  *
4  * Copyright (C) 1999 Linus Torvalds.
5  *
6  * This file is released under the GPL.
7  */
8
9 /*
10  * These are the VFS interfaces to the compressed rom filesystem.
11  * The actual compression is based on zlib, see the other files.
12  */
13
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
16 #include <linux/module.h>
17 #include <linux/fs.h>
18 #include <linux/file.h>
19 #include <linux/pagemap.h>
20 #include <linux/pfn_t.h>
21 #include <linux/ramfs.h>
22 #include <linux/init.h>
23 #include <linux/string.h>
24 #include <linux/blkdev.h>
25 #include <linux/mtd/mtd.h>
26 #include <linux/mtd/super.h>
27 #include <linux/slab.h>
28 #include <linux/vfs.h>
29 #include <linux/mutex.h>
30 #include <uapi/linux/cramfs_fs.h>
31 #include <linux/uaccess.h>
32
33 #include "internal.h"
34
35 /*
36  * cramfs super-block data in memory
37  */
38 struct cramfs_sb_info {
39         unsigned long magic;
40         unsigned long size;
41         unsigned long blocks;
42         unsigned long files;
43         unsigned long flags;
44         void *linear_virt_addr;
45         resource_size_t linear_phys_addr;
46         size_t mtd_point_size;
47 };
48
49 static inline struct cramfs_sb_info *CRAMFS_SB(struct super_block *sb)
50 {
51         return sb->s_fs_info;
52 }
53
54 static const struct super_operations cramfs_ops;
55 static const struct inode_operations cramfs_dir_inode_operations;
56 static const struct file_operations cramfs_directory_operations;
57 static const struct file_operations cramfs_physmem_fops;
58 static const struct address_space_operations cramfs_aops;
59
60 static DEFINE_MUTEX(read_mutex);
61
62
63 /* These macros may change in future, to provide better st_ino semantics. */
64 #define OFFSET(x)       ((x)->i_ino)
65
66 static unsigned long cramino(const struct cramfs_inode *cino, unsigned int offset)
67 {
68         if (!cino->offset)
69                 return offset + 1;
70         if (!cino->size)
71                 return offset + 1;
72
73         /*
74          * The file mode test fixes buggy mkcramfs implementations where
75          * cramfs_inode->offset is set to a non zero value for entries
76          * which did not contain data, like devices node and fifos.
77          */
78         switch (cino->mode & S_IFMT) {
79         case S_IFREG:
80         case S_IFDIR:
81         case S_IFLNK:
82                 return cino->offset << 2;
83         default:
84                 break;
85         }
86         return offset + 1;
87 }
88
89 static struct inode *get_cramfs_inode(struct super_block *sb,
90         const struct cramfs_inode *cramfs_inode, unsigned int offset)
91 {
92         struct inode *inode;
93         static struct timespec64 zerotime;
94
95         inode = iget_locked(sb, cramino(cramfs_inode, offset));
96         if (!inode)
97                 return ERR_PTR(-ENOMEM);
98         if (!(inode->i_state & I_NEW))
99                 return inode;
100
101         switch (cramfs_inode->mode & S_IFMT) {
102         case S_IFREG:
103                 inode->i_fop = &generic_ro_fops;
104                 inode->i_data.a_ops = &cramfs_aops;
105                 if (IS_ENABLED(CONFIG_CRAMFS_MTD) &&
106                     CRAMFS_SB(sb)->flags & CRAMFS_FLAG_EXT_BLOCK_POINTERS &&
107                     CRAMFS_SB(sb)->linear_phys_addr)
108                         inode->i_fop = &cramfs_physmem_fops;
109                 break;
110         case S_IFDIR:
111                 inode->i_op = &cramfs_dir_inode_operations;
112                 inode->i_fop = &cramfs_directory_operations;
113                 break;
114         case S_IFLNK:
115                 inode->i_op = &page_symlink_inode_operations;
116                 inode_nohighmem(inode);
117                 inode->i_data.a_ops = &cramfs_aops;
118                 break;
119         default:
120                 init_special_inode(inode, cramfs_inode->mode,
121                                 old_decode_dev(cramfs_inode->size));
122         }
123
124         inode->i_mode = cramfs_inode->mode;
125         i_uid_write(inode, cramfs_inode->uid);
126         i_gid_write(inode, cramfs_inode->gid);
127
128         /* if the lower 2 bits are zero, the inode contains data */
129         if (!(inode->i_ino & 3)) {
130                 inode->i_size = cramfs_inode->size;
131                 inode->i_blocks = (cramfs_inode->size - 1) / 512 + 1;
132         }
133
134         /* Struct copy intentional */
135         inode->i_mtime = inode->i_atime = inode->i_ctime = zerotime;
136         /* inode->i_nlink is left 1 - arguably wrong for directories,
137            but it's the best we can do without reading the directory
138            contents.  1 yields the right result in GNU find, even
139            without -noleaf option. */
140
141         unlock_new_inode(inode);
142
143         return inode;
144 }
145
146 /*
147  * We have our own block cache: don't fill up the buffer cache
148  * with the rom-image, because the way the filesystem is set
149  * up the accesses should be fairly regular and cached in the
150  * page cache and dentry tree anyway..
151  *
152  * This also acts as a way to guarantee contiguous areas of up to
153  * BLKS_PER_BUF*PAGE_SIZE, so that the caller doesn't need to
154  * worry about end-of-buffer issues even when decompressing a full
155  * page cache.
156  *
157  * Note: This is all optimized away at compile time when
158  *       CONFIG_CRAMFS_BLOCKDEV=n.
159  */
160 #define READ_BUFFERS (2)
161 /* NEXT_BUFFER(): Loop over [0..(READ_BUFFERS-1)]. */
162 #define NEXT_BUFFER(_ix) ((_ix) ^ 1)
163
164 /*
165  * BLKS_PER_BUF_SHIFT should be at least 2 to allow for "compressed"
166  * data that takes up more space than the original and with unlucky
167  * alignment.
168  */
169 #define BLKS_PER_BUF_SHIFT      (2)
170 #define BLKS_PER_BUF            (1 << BLKS_PER_BUF_SHIFT)
171 #define BUFFER_SIZE             (BLKS_PER_BUF*PAGE_SIZE)
172
173 static unsigned char read_buffers[READ_BUFFERS][BUFFER_SIZE];
174 static unsigned buffer_blocknr[READ_BUFFERS];
175 static struct super_block *buffer_dev[READ_BUFFERS];
176 static int next_buffer;
177
178 /*
179  * Populate our block cache and return a pointer to it.
180  */
181 static void *cramfs_blkdev_read(struct super_block *sb, unsigned int offset,
182                                 unsigned int len)
183 {
184         struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping;
185         struct page *pages[BLKS_PER_BUF];
186         unsigned i, blocknr, buffer;
187         unsigned long devsize;
188         char *data;
189
190         if (!len)
191                 return NULL;
192         blocknr = offset >> PAGE_SHIFT;
193         offset &= PAGE_SIZE - 1;
194
195         /* Check if an existing buffer already has the data.. */
196         for (i = 0; i < READ_BUFFERS; i++) {
197                 unsigned int blk_offset;
198
199                 if (buffer_dev[i] != sb)
200                         continue;
201                 if (blocknr < buffer_blocknr[i])
202                         continue;
203                 blk_offset = (blocknr - buffer_blocknr[i]) << PAGE_SHIFT;
204                 blk_offset += offset;
205                 if (blk_offset + len > BUFFER_SIZE)
206                         continue;
207                 return read_buffers[i] + blk_offset;
208         }
209
210         devsize = mapping->host->i_size >> PAGE_SHIFT;
211
212         /* Ok, read in BLKS_PER_BUF pages completely first. */
213         for (i = 0; i < BLKS_PER_BUF; i++) {
214                 struct page *page = NULL;
215
216                 if (blocknr + i < devsize) {
217                         page = read_mapping_page(mapping, blocknr + i, NULL);
218                         /* synchronous error? */
219                         if (IS_ERR(page))
220                                 page = NULL;
221                 }
222                 pages[i] = page;
223         }
224
225         for (i = 0; i < BLKS_PER_BUF; i++) {
226                 struct page *page = pages[i];
227
228                 if (page) {
229                         wait_on_page_locked(page);
230                         if (!PageUptodate(page)) {
231                                 /* asynchronous error */
232                                 put_page(page);
233                                 pages[i] = NULL;
234                         }
235                 }
236         }
237
238         buffer = next_buffer;
239         next_buffer = NEXT_BUFFER(buffer);
240         buffer_blocknr[buffer] = blocknr;
241         buffer_dev[buffer] = sb;
242
243         data = read_buffers[buffer];
244         for (i = 0; i < BLKS_PER_BUF; i++) {
245                 struct page *page = pages[i];
246
247                 if (page) {
248                         memcpy(data, kmap(page), PAGE_SIZE);
249                         kunmap(page);
250                         put_page(page);
251                 } else
252                         memset(data, 0, PAGE_SIZE);
253                 data += PAGE_SIZE;
254         }
255         return read_buffers[buffer] + offset;
256 }
257
258 /*
259  * Return a pointer to the linearly addressed cramfs image in memory.
260  */
261 static void *cramfs_direct_read(struct super_block *sb, unsigned int offset,
262                                 unsigned int len)
263 {
264         struct cramfs_sb_info *sbi = CRAMFS_SB(sb);
265
266         if (!len)
267                 return NULL;
268         if (len > sbi->size || offset > sbi->size - len)
269                 return page_address(ZERO_PAGE(0));
270         return sbi->linear_virt_addr + offset;
271 }
272
273 /*
274  * Returns a pointer to a buffer containing at least LEN bytes of
275  * filesystem starting at byte offset OFFSET into the filesystem.
276  */
277 static void *cramfs_read(struct super_block *sb, unsigned int offset,
278                          unsigned int len)
279 {
280         struct cramfs_sb_info *sbi = CRAMFS_SB(sb);
281
282         if (IS_ENABLED(CONFIG_CRAMFS_MTD) && sbi->linear_virt_addr)
283                 return cramfs_direct_read(sb, offset, len);
284         else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV))
285                 return cramfs_blkdev_read(sb, offset, len);
286         else
287                 return NULL;
288 }
289
290 /*
291  * For a mapping to be possible, we need a range of uncompressed and
292  * contiguous blocks. Return the offset for the first block and number of
293  * valid blocks for which that is true, or zero otherwise.
294  */
295 static u32 cramfs_get_block_range(struct inode *inode, u32 pgoff, u32 *pages)
296 {
297         struct cramfs_sb_info *sbi = CRAMFS_SB(inode->i_sb);
298         int i;
299         u32 *blockptrs, first_block_addr;
300
301         /*
302          * We can dereference memory directly here as this code may be
303          * reached only when there is a direct filesystem image mapping
304          * available in memory.
305          */
306         blockptrs = (u32 *)(sbi->linear_virt_addr + OFFSET(inode) + pgoff * 4);
307         first_block_addr = blockptrs[0] & ~CRAMFS_BLK_FLAGS;
308         i = 0;
309         do {
310                 u32 block_off = i * (PAGE_SIZE >> CRAMFS_BLK_DIRECT_PTR_SHIFT);
311                 u32 expect = (first_block_addr + block_off) |
312                              CRAMFS_BLK_FLAG_DIRECT_PTR |
313                              CRAMFS_BLK_FLAG_UNCOMPRESSED;
314                 if (blockptrs[i] != expect) {
315                         pr_debug("range: block %d/%d got %#x expects %#x\n",
316                                  pgoff+i, pgoff + *pages - 1,
317                                  blockptrs[i], expect);
318                         if (i == 0)
319                                 return 0;
320                         break;
321                 }
322         } while (++i < *pages);
323
324         *pages = i;
325         return first_block_addr << CRAMFS_BLK_DIRECT_PTR_SHIFT;
326 }
327
328 #ifdef CONFIG_MMU
329
330 /*
331  * Return true if the last page of a file in the filesystem image contains
332  * some other data that doesn't belong to that file. It is assumed that the
333  * last block is CRAMFS_BLK_FLAG_DIRECT_PTR | CRAMFS_BLK_FLAG_UNCOMPRESSED
334  * (verified by cramfs_get_block_range() and directly accessible in memory.
335  */
336 static bool cramfs_last_page_is_shared(struct inode *inode)
337 {
338         struct cramfs_sb_info *sbi = CRAMFS_SB(inode->i_sb);
339         u32 partial, last_page, blockaddr, *blockptrs;
340         char *tail_data;
341
342         partial = offset_in_page(inode->i_size);
343         if (!partial)
344                 return false;
345         last_page = inode->i_size >> PAGE_SHIFT;
346         blockptrs = (u32 *)(sbi->linear_virt_addr + OFFSET(inode));
347         blockaddr = blockptrs[last_page] & ~CRAMFS_BLK_FLAGS;
348         blockaddr <<= CRAMFS_BLK_DIRECT_PTR_SHIFT;
349         tail_data = sbi->linear_virt_addr + blockaddr + partial;
350         return memchr_inv(tail_data, 0, PAGE_SIZE - partial) ? true : false;
351 }
352
353 static int cramfs_physmem_mmap(struct file *file, struct vm_area_struct *vma)
354 {
355         struct inode *inode = file_inode(file);
356         struct cramfs_sb_info *sbi = CRAMFS_SB(inode->i_sb);
357         unsigned int pages, max_pages, offset;
358         unsigned long address, pgoff = vma->vm_pgoff;
359         char *bailout_reason;
360         int ret;
361
362         ret = generic_file_readonly_mmap(file, vma);
363         if (ret)
364                 return ret;
365
366         /*
367          * Now try to pre-populate ptes for this vma with a direct
368          * mapping avoiding memory allocation when possible.
369          */
370
371         /* Could COW work here? */
372         bailout_reason = "vma is writable";
373         if (vma->vm_flags & VM_WRITE)
374                 goto bailout;
375
376         max_pages = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
377         bailout_reason = "beyond file limit";
378         if (pgoff >= max_pages)
379                 goto bailout;
380         pages = min(vma_pages(vma), max_pages - pgoff);
381
382         offset = cramfs_get_block_range(inode, pgoff, &pages);
383         bailout_reason = "unsuitable block layout";
384         if (!offset)
385                 goto bailout;
386         address = sbi->linear_phys_addr + offset;
387         bailout_reason = "data is not page aligned";
388         if (!PAGE_ALIGNED(address))
389                 goto bailout;
390
391         /* Don't map the last page if it contains some other data */
392         if (pgoff + pages == max_pages && cramfs_last_page_is_shared(inode)) {
393                 pr_debug("mmap: %s: last page is shared\n",
394                          file_dentry(file)->d_name.name);
395                 pages--;
396         }
397
398         if (!pages) {
399                 bailout_reason = "no suitable block remaining";
400                 goto bailout;
401         }
402
403         if (pages == vma_pages(vma)) {
404                 /*
405                  * The entire vma is mappable. remap_pfn_range() will
406                  * make it distinguishable from a non-direct mapping
407                  * in /proc/<pid>/maps by substituting the file offset
408                  * with the actual physical address.
409                  */
410                 ret = remap_pfn_range(vma, vma->vm_start, address >> PAGE_SHIFT,
411                                       pages * PAGE_SIZE, vma->vm_page_prot);
412         } else {
413                 /*
414                  * Let's create a mixed map if we can't map it all.
415                  * The normal paging machinery will take care of the
416                  * unpopulated ptes via cramfs_readpage().
417                  */
418                 int i;
419                 vma->vm_flags |= VM_MIXEDMAP;
420                 for (i = 0; i < pages && !ret; i++) {
421                         unsigned long off = i * PAGE_SIZE;
422                         pfn_t pfn = phys_to_pfn_t(address + off, PFN_DEV);
423                         ret = vm_insert_mixed(vma, vma->vm_start + off, pfn);
424                 }
425         }
426
427         if (!ret)
428                 pr_debug("mapped %s[%lu] at 0x%08lx (%u/%lu pages) "
429                          "to vma 0x%08lx, page_prot 0x%llx\n",
430                          file_dentry(file)->d_name.name, pgoff,
431                          address, pages, vma_pages(vma), vma->vm_start,
432                          (unsigned long long)pgprot_val(vma->vm_page_prot));
433         return ret;
434
435 bailout:
436         pr_debug("%s[%lu]: direct mmap impossible: %s\n",
437                  file_dentry(file)->d_name.name, pgoff, bailout_reason);
438         /* Didn't manage any direct map, but normal paging is still possible */
439         return 0;
440 }
441
442 #else /* CONFIG_MMU */
443
444 static int cramfs_physmem_mmap(struct file *file, struct vm_area_struct *vma)
445 {
446         return vma->vm_flags & (VM_SHARED | VM_MAYSHARE) ? 0 : -ENOSYS;
447 }
448
449 static unsigned long cramfs_physmem_get_unmapped_area(struct file *file,
450                         unsigned long addr, unsigned long len,
451                         unsigned long pgoff, unsigned long flags)
452 {
453         struct inode *inode = file_inode(file);
454         struct super_block *sb = inode->i_sb;
455         struct cramfs_sb_info *sbi = CRAMFS_SB(sb);
456         unsigned int pages, block_pages, max_pages, offset;
457
458         pages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
459         max_pages = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
460         if (pgoff >= max_pages || pages > max_pages - pgoff)
461                 return -EINVAL;
462         block_pages = pages;
463         offset = cramfs_get_block_range(inode, pgoff, &block_pages);
464         if (!offset || block_pages != pages)
465                 return -ENOSYS;
466         addr = sbi->linear_phys_addr + offset;
467         pr_debug("get_unmapped for %s ofs %#lx siz %lu at 0x%08lx\n",
468                  file_dentry(file)->d_name.name, pgoff*PAGE_SIZE, len, addr);
469         return addr;
470 }
471
472 static unsigned int cramfs_physmem_mmap_capabilities(struct file *file)
473 {
474         return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT |
475                NOMMU_MAP_READ | NOMMU_MAP_EXEC;
476 }
477
478 #endif /* CONFIG_MMU */
479
480 static const struct file_operations cramfs_physmem_fops = {
481         .llseek                 = generic_file_llseek,
482         .read_iter              = generic_file_read_iter,
483         .splice_read            = generic_file_splice_read,
484         .mmap                   = cramfs_physmem_mmap,
485 #ifndef CONFIG_MMU
486         .get_unmapped_area      = cramfs_physmem_get_unmapped_area,
487         .mmap_capabilities      = cramfs_physmem_mmap_capabilities,
488 #endif
489 };
490
491 static void cramfs_kill_sb(struct super_block *sb)
492 {
493         struct cramfs_sb_info *sbi = CRAMFS_SB(sb);
494
495         if (IS_ENABLED(CONFIG_CRAMFS_MTD) && sb->s_mtd) {
496                 if (sbi && sbi->mtd_point_size)
497                         mtd_unpoint(sb->s_mtd, 0, sbi->mtd_point_size);
498                 kill_mtd_super(sb);
499         } else if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV) && sb->s_bdev) {
500                 kill_block_super(sb);
501         }
502         kfree(sbi);
503 }
504
505 static int cramfs_remount(struct super_block *sb, int *flags, char *data)
506 {
507         sync_filesystem(sb);
508         *flags |= SB_RDONLY;
509         return 0;
510 }
511
512 static int cramfs_read_super(struct super_block *sb,
513                              struct cramfs_super *super, int silent)
514 {
515         struct cramfs_sb_info *sbi = CRAMFS_SB(sb);
516         unsigned long root_offset;
517
518         /* We don't know the real size yet */
519         sbi->size = PAGE_SIZE;
520
521         /* Read the first block and get the superblock from it */
522         mutex_lock(&read_mutex);
523         memcpy(super, cramfs_read(sb, 0, sizeof(*super)), sizeof(*super));
524         mutex_unlock(&read_mutex);
525
526         /* Do sanity checks on the superblock */
527         if (super->magic != CRAMFS_MAGIC) {
528                 /* check for wrong endianness */
529                 if (super->magic == CRAMFS_MAGIC_WEND) {
530                         if (!silent)
531                                 pr_err("wrong endianness\n");
532                         return -EINVAL;
533                 }
534
535                 /* check at 512 byte offset */
536                 mutex_lock(&read_mutex);
537                 memcpy(super,
538                        cramfs_read(sb, 512, sizeof(*super)),
539                        sizeof(*super));
540                 mutex_unlock(&read_mutex);
541                 if (super->magic != CRAMFS_MAGIC) {
542                         if (super->magic == CRAMFS_MAGIC_WEND && !silent)
543                                 pr_err("wrong endianness\n");
544                         else if (!silent)
545                                 pr_err("wrong magic\n");
546                         return -EINVAL;
547                 }
548         }
549
550         /* get feature flags first */
551         if (super->flags & ~CRAMFS_SUPPORTED_FLAGS) {
552                 pr_err("unsupported filesystem features\n");
553                 return -EINVAL;
554         }
555
556         /* Check that the root inode is in a sane state */
557         if (!S_ISDIR(super->root.mode)) {
558                 pr_err("root is not a directory\n");
559                 return -EINVAL;
560         }
561         /* correct strange, hard-coded permissions of mkcramfs */
562         super->root.mode |= 0555;
563
564         root_offset = super->root.offset << 2;
565         if (super->flags & CRAMFS_FLAG_FSID_VERSION_2) {
566                 sbi->size = super->size;
567                 sbi->blocks = super->fsid.blocks;
568                 sbi->files = super->fsid.files;
569         } else {
570                 sbi->size = 1<<28;
571                 sbi->blocks = 0;
572                 sbi->files = 0;
573         }
574         sbi->magic = super->magic;
575         sbi->flags = super->flags;
576         if (root_offset == 0)
577                 pr_info("empty filesystem");
578         else if (!(super->flags & CRAMFS_FLAG_SHIFTED_ROOT_OFFSET) &&
579                  ((root_offset != sizeof(struct cramfs_super)) &&
580                   (root_offset != 512 + sizeof(struct cramfs_super))))
581         {
582                 pr_err("bad root offset %lu\n", root_offset);
583                 return -EINVAL;
584         }
585
586         return 0;
587 }
588
589 static int cramfs_finalize_super(struct super_block *sb,
590                                  struct cramfs_inode *cramfs_root)
591 {
592         struct inode *root;
593
594         /* Set it all up.. */
595         sb->s_flags |= SB_RDONLY;
596         sb->s_op = &cramfs_ops;
597         root = get_cramfs_inode(sb, cramfs_root, 0);
598         if (IS_ERR(root))
599                 return PTR_ERR(root);
600         sb->s_root = d_make_root(root);
601         if (!sb->s_root)
602                 return -ENOMEM;
603         return 0;
604 }
605
606 static int cramfs_blkdev_fill_super(struct super_block *sb, void *data,
607                                     int silent)
608 {
609         struct cramfs_sb_info *sbi;
610         struct cramfs_super super;
611         int i, err;
612
613         sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL);
614         if (!sbi)
615                 return -ENOMEM;
616         sb->s_fs_info = sbi;
617
618         /* Invalidate the read buffers on mount: think disk change.. */
619         for (i = 0; i < READ_BUFFERS; i++)
620                 buffer_blocknr[i] = -1;
621
622         err = cramfs_read_super(sb, &super, silent);
623         if (err)
624                 return err;
625         return cramfs_finalize_super(sb, &super.root);
626 }
627
628 static int cramfs_mtd_fill_super(struct super_block *sb, void *data,
629                                  int silent)
630 {
631         struct cramfs_sb_info *sbi;
632         struct cramfs_super super;
633         int err;
634
635         sbi = kzalloc(sizeof(struct cramfs_sb_info), GFP_KERNEL);
636         if (!sbi)
637                 return -ENOMEM;
638         sb->s_fs_info = sbi;
639
640         /* Map only one page for now.  Will remap it when fs size is known. */
641         err = mtd_point(sb->s_mtd, 0, PAGE_SIZE, &sbi->mtd_point_size,
642                         &sbi->linear_virt_addr, &sbi->linear_phys_addr);
643         if (err || sbi->mtd_point_size != PAGE_SIZE) {
644                 pr_err("unable to get direct memory access to mtd:%s\n",
645                        sb->s_mtd->name);
646                 return err ? : -ENODATA;
647         }
648
649         pr_info("checking physical address %pap for linear cramfs image\n",
650                 &sbi->linear_phys_addr);
651         err = cramfs_read_super(sb, &super, silent);
652         if (err)
653                 return err;
654
655         /* Remap the whole filesystem now */
656         pr_info("linear cramfs image on mtd:%s appears to be %lu KB in size\n",
657                 sb->s_mtd->name, sbi->size/1024);
658         mtd_unpoint(sb->s_mtd, 0, PAGE_SIZE);
659         err = mtd_point(sb->s_mtd, 0, sbi->size, &sbi->mtd_point_size,
660                         &sbi->linear_virt_addr, &sbi->linear_phys_addr);
661         if (err || sbi->mtd_point_size != sbi->size) {
662                 pr_err("unable to get direct memory access to mtd:%s\n",
663                        sb->s_mtd->name);
664                 return err ? : -ENODATA;
665         }
666
667         return cramfs_finalize_super(sb, &super.root);
668 }
669
670 static int cramfs_statfs(struct dentry *dentry, struct kstatfs *buf)
671 {
672         struct super_block *sb = dentry->d_sb;
673         u64 id = 0;
674
675         if (sb->s_bdev)
676                 id = huge_encode_dev(sb->s_bdev->bd_dev);
677         else if (sb->s_dev)
678                 id = huge_encode_dev(sb->s_dev);
679
680         buf->f_type = CRAMFS_MAGIC;
681         buf->f_bsize = PAGE_SIZE;
682         buf->f_blocks = CRAMFS_SB(sb)->blocks;
683         buf->f_bfree = 0;
684         buf->f_bavail = 0;
685         buf->f_files = CRAMFS_SB(sb)->files;
686         buf->f_ffree = 0;
687         buf->f_fsid.val[0] = (u32)id;
688         buf->f_fsid.val[1] = (u32)(id >> 32);
689         buf->f_namelen = CRAMFS_MAXPATHLEN;
690         return 0;
691 }
692
693 /*
694  * Read a cramfs directory entry.
695  */
696 static int cramfs_readdir(struct file *file, struct dir_context *ctx)
697 {
698         struct inode *inode = file_inode(file);
699         struct super_block *sb = inode->i_sb;
700         char *buf;
701         unsigned int offset;
702
703         /* Offset within the thing. */
704         if (ctx->pos >= inode->i_size)
705                 return 0;
706         offset = ctx->pos;
707         /* Directory entries are always 4-byte aligned */
708         if (offset & 3)
709                 return -EINVAL;
710
711         buf = kmalloc(CRAMFS_MAXPATHLEN, GFP_KERNEL);
712         if (!buf)
713                 return -ENOMEM;
714
715         while (offset < inode->i_size) {
716                 struct cramfs_inode *de;
717                 unsigned long nextoffset;
718                 char *name;
719                 ino_t ino;
720                 umode_t mode;
721                 int namelen;
722
723                 mutex_lock(&read_mutex);
724                 de = cramfs_read(sb, OFFSET(inode) + offset, sizeof(*de)+CRAMFS_MAXPATHLEN);
725                 name = (char *)(de+1);
726
727                 /*
728                  * Namelengths on disk are shifted by two
729                  * and the name padded out to 4-byte boundaries
730                  * with zeroes.
731                  */
732                 namelen = de->namelen << 2;
733                 memcpy(buf, name, namelen);
734                 ino = cramino(de, OFFSET(inode) + offset);
735                 mode = de->mode;
736                 mutex_unlock(&read_mutex);
737                 nextoffset = offset + sizeof(*de) + namelen;
738                 for (;;) {
739                         if (!namelen) {
740                                 kfree(buf);
741                                 return -EIO;
742                         }
743                         if (buf[namelen-1])
744                                 break;
745                         namelen--;
746                 }
747                 if (!dir_emit(ctx, buf, namelen, ino, mode >> 12))
748                         break;
749
750                 ctx->pos = offset = nextoffset;
751         }
752         kfree(buf);
753         return 0;
754 }
755
756 /*
757  * Lookup and fill in the inode data..
758  */
759 static struct dentry *cramfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
760 {
761         unsigned int offset = 0;
762         struct inode *inode = NULL;
763         int sorted;
764
765         mutex_lock(&read_mutex);
766         sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS;
767         while (offset < dir->i_size) {
768                 struct cramfs_inode *de;
769                 char *name;
770                 int namelen, retval;
771                 int dir_off = OFFSET(dir) + offset;
772
773                 de = cramfs_read(dir->i_sb, dir_off, sizeof(*de)+CRAMFS_MAXPATHLEN);
774                 name = (char *)(de+1);
775
776                 /* Try to take advantage of sorted directories */
777                 if (sorted && (dentry->d_name.name[0] < name[0]))
778                         break;
779
780                 namelen = de->namelen << 2;
781                 offset += sizeof(*de) + namelen;
782
783                 /* Quick check that the name is roughly the right length */
784                 if (((dentry->d_name.len + 3) & ~3) != namelen)
785                         continue;
786
787                 for (;;) {
788                         if (!namelen) {
789                                 inode = ERR_PTR(-EIO);
790                                 goto out;
791                         }
792                         if (name[namelen-1])
793                                 break;
794                         namelen--;
795                 }
796                 if (namelen != dentry->d_name.len)
797                         continue;
798                 retval = memcmp(dentry->d_name.name, name, namelen);
799                 if (retval > 0)
800                         continue;
801                 if (!retval) {
802                         inode = get_cramfs_inode(dir->i_sb, de, dir_off);
803                         break;
804                 }
805                 /* else (retval < 0) */
806                 if (sorted)
807                         break;
808         }
809 out:
810         mutex_unlock(&read_mutex);
811         return d_splice_alias(inode, dentry);
812 }
813
814 static int cramfs_readpage(struct file *file, struct page *page)
815 {
816         struct inode *inode = page->mapping->host;
817         u32 maxblock;
818         int bytes_filled;
819         void *pgdata;
820
821         maxblock = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
822         bytes_filled = 0;
823         pgdata = kmap(page);
824
825         if (page->index < maxblock) {
826                 struct super_block *sb = inode->i_sb;
827                 u32 blkptr_offset = OFFSET(inode) + page->index * 4;
828                 u32 block_ptr, block_start, block_len;
829                 bool uncompressed, direct;
830
831                 mutex_lock(&read_mutex);
832                 block_ptr = *(u32 *) cramfs_read(sb, blkptr_offset, 4);
833                 uncompressed = (block_ptr & CRAMFS_BLK_FLAG_UNCOMPRESSED);
834                 direct = (block_ptr & CRAMFS_BLK_FLAG_DIRECT_PTR);
835                 block_ptr &= ~CRAMFS_BLK_FLAGS;
836
837                 if (direct) {
838                         /*
839                          * The block pointer is an absolute start pointer,
840                          * shifted by 2 bits. The size is included in the
841                          * first 2 bytes of the data block when compressed,
842                          * or PAGE_SIZE otherwise.
843                          */
844                         block_start = block_ptr << CRAMFS_BLK_DIRECT_PTR_SHIFT;
845                         if (uncompressed) {
846                                 block_len = PAGE_SIZE;
847                                 /* if last block: cap to file length */
848                                 if (page->index == maxblock - 1)
849                                         block_len =
850                                                 offset_in_page(inode->i_size);
851                         } else {
852                                 block_len = *(u16 *)
853                                         cramfs_read(sb, block_start, 2);
854                                 block_start += 2;
855                         }
856                 } else {
857                         /*
858                          * The block pointer indicates one past the end of
859                          * the current block (start of next block). If this
860                          * is the first block then it starts where the block
861                          * pointer table ends, otherwise its start comes
862                          * from the previous block's pointer.
863                          */
864                         block_start = OFFSET(inode) + maxblock * 4;
865                         if (page->index)
866                                 block_start = *(u32 *)
867                                         cramfs_read(sb, blkptr_offset - 4, 4);
868                         /* Beware... previous ptr might be a direct ptr */
869                         if (unlikely(block_start & CRAMFS_BLK_FLAG_DIRECT_PTR)) {
870                                 /* See comments on earlier code. */
871                                 u32 prev_start = block_start;
872                                block_start = prev_start & ~CRAMFS_BLK_FLAGS;
873                                block_start <<= CRAMFS_BLK_DIRECT_PTR_SHIFT;
874                                 if (prev_start & CRAMFS_BLK_FLAG_UNCOMPRESSED) {
875                                         block_start += PAGE_SIZE;
876                                 } else {
877                                         block_len = *(u16 *)
878                                                 cramfs_read(sb, block_start, 2);
879                                         block_start += 2 + block_len;
880                                 }
881                         }
882                         block_start &= ~CRAMFS_BLK_FLAGS;
883                         block_len = block_ptr - block_start;
884                 }
885
886                 if (block_len == 0)
887                         ; /* hole */
888                 else if (unlikely(block_len > 2*PAGE_SIZE ||
889                                   (uncompressed && block_len > PAGE_SIZE))) {
890                         mutex_unlock(&read_mutex);
891                         pr_err("bad data blocksize %u\n", block_len);
892                         goto err;
893                 } else if (uncompressed) {
894                         memcpy(pgdata,
895                                cramfs_read(sb, block_start, block_len),
896                                block_len);
897                         bytes_filled = block_len;
898                 } else {
899                         bytes_filled = cramfs_uncompress_block(pgdata,
900                                  PAGE_SIZE,
901                                  cramfs_read(sb, block_start, block_len),
902                                  block_len);
903                 }
904                 mutex_unlock(&read_mutex);
905                 if (unlikely(bytes_filled < 0))
906                         goto err;
907         }
908
909         memset(pgdata + bytes_filled, 0, PAGE_SIZE - bytes_filled);
910         flush_dcache_page(page);
911         kunmap(page);
912         SetPageUptodate(page);
913         unlock_page(page);
914         return 0;
915
916 err:
917         kunmap(page);
918         ClearPageUptodate(page);
919         SetPageError(page);
920         unlock_page(page);
921         return 0;
922 }
923
924 static const struct address_space_operations cramfs_aops = {
925         .readpage = cramfs_readpage
926 };
927
928 /*
929  * Our operations:
930  */
931
932 /*
933  * A directory can only readdir
934  */
935 static const struct file_operations cramfs_directory_operations = {
936         .llseek         = generic_file_llseek,
937         .read           = generic_read_dir,
938         .iterate_shared = cramfs_readdir,
939 };
940
941 static const struct inode_operations cramfs_dir_inode_operations = {
942         .lookup         = cramfs_lookup,
943 };
944
945 static const struct super_operations cramfs_ops = {
946         .remount_fs     = cramfs_remount,
947         .statfs         = cramfs_statfs,
948 };
949
950 static struct dentry *cramfs_mount(struct file_system_type *fs_type, int flags,
951                                    const char *dev_name, void *data)
952 {
953         struct dentry *ret = ERR_PTR(-ENOPROTOOPT);
954
955         if (IS_ENABLED(CONFIG_CRAMFS_MTD)) {
956                 ret = mount_mtd(fs_type, flags, dev_name, data,
957                                 cramfs_mtd_fill_super);
958                 if (!IS_ERR(ret))
959                         return ret;
960         }
961         if (IS_ENABLED(CONFIG_CRAMFS_BLOCKDEV)) {
962                 ret = mount_bdev(fs_type, flags, dev_name, data,
963                                  cramfs_blkdev_fill_super);
964         }
965         return ret;
966 }
967
968 static struct file_system_type cramfs_fs_type = {
969         .owner          = THIS_MODULE,
970         .name           = "cramfs",
971         .mount          = cramfs_mount,
972         .kill_sb        = cramfs_kill_sb,
973         .fs_flags       = FS_REQUIRES_DEV,
974 };
975 MODULE_ALIAS_FS("cramfs");
976
977 static int __init init_cramfs_fs(void)
978 {
979         int rv;
980
981         rv = cramfs_uncompress_init();
982         if (rv < 0)
983                 return rv;
984         rv = register_filesystem(&cramfs_fs_type);
985         if (rv < 0)
986                 cramfs_uncompress_exit();
987         return rv;
988 }
989
990 static void __exit exit_cramfs_fs(void)
991 {
992         cramfs_uncompress_exit();
993         unregister_filesystem(&cramfs_fs_type);
994 }
995
996 module_init(init_cramfs_fs)
997 module_exit(exit_cramfs_fs)
998 MODULE_LICENSE("GPL");