Re: AMP on an SMP system
Il 02/08/2013 14:13, Michael Schnell ha scritto: On 08/02/2013 01:42 PM, Robert Schwebel wrote: Before hacking around (which might also lead to interesting solutions), I would start using a kernel with preempt-rt support and play with the cpu affinity: http://lxr.linux.no/#linux+v3.10.4/Documentation/kernel-parameters.txt#L1257 Robert ! Nice to see you here (I do own your Embedded Linux Handbuch für Entwickler :-) ) Thanks for the pointer ! I do already know preempt-rt, but I was not aware of cpu affinity. So this might help. In fact I need a way to do very guaranteed low latency. regarding the high clock rate (about 1 GHz) modern ARM chips can provide, maybe preempt-rt with the cpu affinity might be a decent way to go. Just to be clear: at the moment there isn't an easy way to dedicate completely a cpu for a task. The last time I tried (some years ago actually) to use exclusive cpu set, the scheduler didn't do a good work because it was designed for SMP, not SMP minus some piece. However you can try and you can report your results. It would be interesting. The raining questions include - how to calculate the maximum latency that can be guaranteed ? (i.e. does the Kernel impose any spinlocks and interrupt disables on the would be AMP subsystem ?) No. You can use full dyn tick for example to disable timer interrupt, but it has got some pros and cons, especially with very low latency requirement. - how to assign an interrupt (e.g. a dedicated timer) to the subsystem ? Interrupt handler are kernel thread, so you can schedule your kernel thread on your normal cpu. - Do the interrupts immediately call the ISR of the cpu under affinity or is some additional latency imposed by the Kernel AFAIC, no latency for cpu under affinity. (and how many cpu cycles at max are needed to enter the ISR) ? It's difficult to answer to this question because the performance depends on your system. From my last statistics I saw that with an rt linux kernel you can stay below 50us for the interrupt latency. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: AMP on an SMP system
Il 02/08/2013 17:24, Michael Schnell ha scritto: On 08/02/2013 04:53 PM, Marco Stornelli wrote: - how to assign an interrupt (e.g. a dedicated timer) to the subsystem ? Interrupt handler are kernel thread, so you can schedule your kernel thread on your normal cpu. Sorry. I don't understand. The point I'd like to make is, that for really low latency stuff the ISR needs to take place immediately when the hardware fires an interrupt. As the Linux kernel will (for the SMP CPUs it handles) need to disable interrupt in certain cases, it is essential that the really low latency interrupt is assigned to the AMP cpu (that the Kernel will never touch). AFAIC, no latency for cpu under affinity. That would be great but it need the stuff described above. In fact the interrupt would need to be assigned to the AMP cpu by some hardware means (that I don't know anything about yet), and not be forwarded in any way from some other cpu (which is managed by the Kernel) and thus might be in a interrupt disable state at some point in time. I don't know your hw so my consideration are really general. ISRs in rt kernel doesn't exist or at least the only work is to wake up the kernel thread for the management. The thing you can do is to move the kernel thread for interrupt X where you want to manage it, or you can set a specific scheduler policy. For example you can set a SCHED_FIFO with a very high priority for your really low latency tasks. RT kernel does the work for you :) You can see here: http://lwn.net/Articles/146861/ Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: AMP on an SMP system
Il 02/08/2013 18:00, Michael Schnell ha scritto: On 08/02/2013 05:37 PM, Marco Stornelli wrote: I don't know your hw so my consideration are really general. The hardware is not decided yet (it will be some A9 thingy). So for me really general is just fine. ISRs in rt kernel doesn't exist or at least the only work is to wake up the kernel thread for the management. I see. But how to determine the max latency for this ? Maybe on eLinux.org you can find some number. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: Expose system Serial Number to userspace.
Il 29/08/2012 17:18, Brad Arnold ha scritto: Hi, I'm working on an embedded board which uses u-boot + linux. At manufacturing time, the device serial number will be programmed into OTP memory on NAND (probably from within u-boot). We'd like the linux kernel to make this serial number available to be read from userspace. Is there an accepted method to do this sort of thing? One idea I had was to make the serial number available as a device node (ie: you can simply read the serial number from /dev/serialnumber). Then there's the question of how the kernel learns the serial in the first place (a kernel boot command like parameter passed from u-boot?). Does this sound sane, or is there a better way to do something like this? Thanks, Brad U-Boot manage a serial number via env variable serial#. It provides several tools. You'll find under tools/env applications to read/write env variable of uboot, so reading from Linux is very simple. You should use a dedicated little space of flash to store the env variables. Regards, Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: Expose system Serial Number to userspace.
Il 29/08/2012 18:57, Brad Arnold ha scritto: That'll help me move along. I'm currently storing the mac and serial in the u-boot environment, but I was thinking I might want to move those two to the OTP. But at least having some level of write protection in u-boot is nice. I wasn't aware that this existed, because it's disabled by default in the config for Marvell boards. I'll have to look at that example program futher... Brad (Please no top-posting). Of course, if you have got a separate flash partition for the uboot env, you can map it read-only in linux, it's safer. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: Super Fast Boot of Embedded Linux: 300 ms from boot loader to shell
Il 13/04/2011 16:53, Constantine Shulyupin ha scritto: Thank you Marco for your feedback. I've added summary of used optimization method: • Reduction of kernel and filesystem size • Kernel features: naked boot, initrd without compression • Optimization of NAND flash interface in boot loader • Boot time was measured with utility tstamp • You can find more detailed list of methods at http://elinux.org/Boot_Time • Techniques for improving embedded Linux startup time, presentation: http://www.makelinux.com/emb/fastboot/MontaVista Actually, detailed implementations of optimization methods are described in numerous documents. I really know. I was talking about *your* optimization method, but if I well understand you've just applied a list of well known methods. -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: Super Fast Boot of Embedded Linux: 300 ms from boot loader to shell
Il 11/04/2011 16:02, Constantine Shulyupin ha scritto: Hello all, Make Linux Software presents the fastest ever embedded Linux boot for 720 MHz ARM and NAND flash memory. Linux boot time is 300 milliseconds from boot loader to shell. The first goal of the project is to achieve a minimal boot time of a minimal but functional Linux system on common hardware. The second goal is to provide a platform for developing more functional systems with an even minimized boot time. Hi, is it a marketing announcement or a presentation of an innovative solution? In the first case don't send this kind of email to this mailing list. In the second one, could you explain to us your fast boot solution or your kernel modifications? I can't find any implementation details on the web site. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH] Kconfig: XIP doesn't depend on block
From: Marco Stornelli marco.storne...@gmail.com XIP doesn't depend on block symbol, then we can reorder the Kconfig. For ext2 doesn't change the Kconfig behavior but if other fs will use FS_XIP it won't need to include block support if not needed. Signed-off-by: Marco Stornelli marco.storne...@gmail.com --- --- Kconfig.orig2011-01-19 00:14:02.0 +0100 +++ Kconfig 2011-02-06 16:04:51.0 +0100 @@ -9,13 +9,6 @@ if BLOCK source fs/ext2/Kconfig source fs/ext3/Kconfig source fs/ext4/Kconfig - -config FS_XIP -# execute in place - bool - depends on EXT2_FS_XIP - default y - source fs/jbd/Kconfig source fs/jbd2/Kconfig @@ -38,6 +31,12 @@ source fs/nilfs2/Kconfig endif # BLOCK +config FS_XIP +# execute in place + bool + depends on EXT2_FS_XIP + default y + # Posix ACL utility routines # # Note: Posix ACLs can be implemented without these helpers. Never use -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH] Kconfig: XIP doesn't depend on block
2011/2/6 Randy Dunlap rdun...@xenotime.net: On Sun, 06 Feb 2011 16:15:00 +0100 Marco Stornelli wrote: From: Marco Stornelli marco.storne...@gmail.com XIP doesn't depend on block symbol, then we can reorder the Kconfig. For ext2 doesn't change the Kconfig behavior but if other fs will use FS_XIP it won't need to include block support if not needed. Hi Marco, Do you know of a filesystem where this matters? Yes, for example mine (pramfs) :) Signed-off-by: Marco Stornelli marco.storne...@gmail.com --- --- Kconfig.orig 2011-01-19 00:14:02.0 +0100 +++ Kconfig 2011-02-06 16:04:51.0 +0100 This filename should include path, like --- fs/Kconfig.orig +++ fs/Kconfig @@ -9,13 +9,6 @@ if BLOCK source fs/ext2/Kconfig source fs/ext3/Kconfig source fs/ext4/Kconfig - The 3 filesystems above are immediately under: if BLOCK so ext[234] depend on BLOCK. Why would it matter about FS_XIP? I don't know but for example even POSIX ACL was under if BLOCK, maybe there is only an historical refuse. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 01/17] pramfs: documentation
2011/1/10 Pavel Machek pa...@ucw.cz: On 07/01/2011 22:59, Tony Luck wrote: On Fri, Jan 7, 2011 at 12:30 PM, Marco Stornelli marco.storne...@gmail.com wrote: constraint). About the errors: pramfs does not maintain file data in the page caches for normal file I/O, so no writeback, the read/write operation are done with direct io and they are always sync. The data are write protected in hw when the arch provide this facility (x86 does). Inode contains a checksum and when there are problems they are marked as bad. Superblock contains checksum and there is a redundant superblock. But you can still get pramfs inconsistencies if the system crashes at an inopportune moment. E.g. when making files you write the new inode to pramfs, and then you insert the entry into the directory. A crash between these two operations leaves an allocated inode that doesn't appear in any directory. Without a fsck option, it will be hard to see that you have this problem, and your only recovery option is to wipe *all* files by making a new filesystem. Is it a problem if you lost some logs? However do you expect that fsck in this case will drop the inode? Ask it the other way around. What is persistent filesystem good for when it is only persistent sometimes? You'd be better running ext2 over special block device, it is quite simple. Ok I can work on it. However can an userspace tool prevent the insert of fs in linux next? Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 01/17] pramfs: documentation
Il 10/01/2011 18:35, Luck, Tony ha scritto: You'd be better running ext2 over special block device, it is quite simple. Marco, You might want to spend some more time answering this question (it is a particularly good one). What are the reasons to use pramfs, rather than a ext2 over a mem-block driver. You covered some in your part 0 patch (like ext2 wastes time getting optimal block placement for rotating media). But it might be a good idea to go back over them here. From my (lightweight) reading of your code, it looks like the biggest benefit is avoiding duplicating the data in the pramfs memory region and the VM page cache ... which is a big deal for your target audience of hand held devices where memory is a somewhat scarce resource. But you probably have other goodness in there too. -Tony I can add that you can place the fs wherever you want, ext2 not without to build something special as Pavel said. Sincerely I don't know what other add. I think documentation, web site information and benchmark say all. You have got a fs that it's simple, it doesn't consume a lot of resources (you can do a fine tuning via N and bpi options for the metadata space for example), better in performance in this environment, with the memory protection feature when availableother? I could write a piece of code that it turn on your coffee machine at morning, what do you think? :) Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 01/17] pramfs: documentation
On 07/01/2011 22:59, Tony Luck wrote: On Fri, Jan 7, 2011 at 12:30 PM, Marco Stornelli marco.storne...@gmail.com wrote: constraint). About the errors: pramfs does not maintain file data in the page caches for normal file I/O, so no writeback, the read/write operation are done with direct io and they are always sync. The data are write protected in hw when the arch provide this facility (x86 does). Inode contains a checksum and when there are problems they are marked as bad. Superblock contains checksum and there is a redundant superblock. But you can still get pramfs inconsistencies if the system crashes at an inopportune moment. E.g. when making files you write the new inode to pramfs, and then you insert the entry into the directory. A crash between these two operations leaves an allocated inode that doesn't appear in any directory. Without a fsck option, it will be hard to see that you have this problem, and your only recovery option is to wipe *all* files by making a new filesystem. Is it a problem if you lost some logs? However do you expect that fsck in this case will drop the inode? -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 01/17] pramfs: documentation
Il 07/01/2011 19:42, Tony Luck ha scritto: On Thu, Jan 6, 2011 at 4:01 AM, Marco Stornelli marco.storne...@gmail.com wrote: +accessed data that must survive system reboots and power cycles. An +example usage might be system logs under /var/log, or a user address +book in a cell phone or PDA. Some usage model questions: How do you handle errors? I see that there are a few sanity checks in the mount path ... but there would seem to be several opportunities for the file system to get corrupted in other ways. Since you don't have a block device, a standard fsck program looks challenging (though I guess you could mmap(/dev/mem) to peek poke at the filesystem before trying to mount it). Actually not (at least when strict devmem options is turned on) because the memory region is marked exclusive at the moment (only a design constraint). About the errors: pramfs does not maintain file data in the page caches for normal file I/O, so no writeback, the read/write operation are done with direct io and they are always sync. The data are write protected in hw when the arch provide this facility (x86 does). Inode contains a checksum and when there are problems they are marked as bad. Superblock contains checksum and there is a redundant superblock. Some sort of recovery path would seem useful for the address book use model ... or do you just expect users to back their address book up (to the cloud?) and have the phone just make a clean filesystem if any errors are found? Yeah maybe the address book can be a case not perfectly suitable, but it was only an example. I thought about the fs as a cache in this use case. However the designer can use this area whatever he wants, recently I saw in a project this fs used as a system cache for decrypted files where the files were stored in flash encrypted, so I think it's flexible. What about quotas? You have a fixed amount of persistent space, and presumably a number of apps that the user installs on their device that may like to use pramfs to store data. Do you need some kernel enforcement to stop one rogue application from using up all the space? Or do you expect that this would be handled in some library level interface that applications will use to access pramfs? Sincerely in my embedded systems I've never used quotas even to save footprint (for the kernel support I mean). I don't think it's an hot feature in this case and other fs for embedded use as ubifs, jffs2 etc. don't support it. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 00/17] pramfs: persistent and protected RAM filesystem
Hi all, after several reviews is time to submit the code for mainline. Thanks to CELF to believe and support actively the project and thanks to Tim Bird. Here the stats: Documentation/filesystems/pramfs.txt | 179 ++ Documentation/filesystems/xip.txt|2 + arch/Kconfig |3 + arch/x86/Kconfig |1 + fs/Kconfig |8 +- fs/Makefile |1 + fs/pramfs/Kconfig| 72 +++ fs/pramfs/Makefile | 14 + fs/pramfs/acl.c | 433 + fs/pramfs/acl.h | 86 +++ fs/pramfs/balloc.c | 147 + fs/pramfs/desctree.c | 181 ++ fs/pramfs/desctree.h | 44 ++ fs/pramfs/dir.c | 208 +++ fs/pramfs/file.c | 326 ++ fs/pramfs/inode.c| 848 ++ fs/pramfs/ioctl.c| 121 fs/pramfs/namei.c| 371 fs/pramfs/pram.h | 269 + fs/pramfs/pramfs_test.c | 47 ++ fs/pramfs/super.c| 940 + fs/pramfs/symlink.c | 76 +++ fs/pramfs/wprotect.c | 41 ++ fs/pramfs/wprotect.h | 151 + fs/pramfs/xattr.c| 1104 ++ fs/pramfs/xattr.h| 131 fs/pramfs/xattr_security.c | 78 +++ fs/pramfs/xattr_trusted.c| 65 ++ fs/pramfs/xattr_user.c | 68 +++ fs/pramfs/xip.c | 83 +++ fs/pramfs/xip.h | 28 + include/linux/magic.h|1 + include/linux/pram_fs.h | 130 include/linux/pram_fs_sb.h | 45 ++ 34 files changed, 6299 insertions(+), 3 deletions(-) Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 01/17] pramfs: documentation
From: Marco Stornelli marco.storne...@gmail.com Documentation for PRAMFS. Signed-off-by: Marco Stornelli marco.storne...@gmail.com --- diff --git a/Documentation/filesystems/pramfs.txt b/Documentation/filesystems/pramfs.txt new file mode 100644 index 000..2ad536f --- /dev/null +++ b/Documentation/filesystems/pramfs.txt @@ -0,0 +1,179 @@ + +PRAMFS Overview +=== + +Many embedded systems have a block of non-volatile RAM separate from +normal system memory, i.e. of which the kernel maintains no memory page +descriptors. For such systems it would be beneficial to mount a +fast read/write filesystem over this I/O memory, for storing frequently +accessed data that must survive system reboots and power cycles. An +example usage might be system logs under /var/log, or a user address +book in a cell phone or PDA. + +Linux traditionally had no support for a persistent, non-volatile RAM-based +filesystem, persistent meaning the filesystem survives a system reboot +or power cycle intact. The RAM-based filesystems such as tmpfs and ramfs +have no actual backing store but exist entirely in the page and buffer +caches, hence the filesystem disappears after a system reboot or +power cycle. + +A relatively straightforward solution is to write a simple block driver +for the non-volatile RAM, and mount over it any disk-based filesystem such +as ext2, ext3, ext4, etc. + +But the disk-based fs over non-volatile RAM block driver approach has +some drawbacks: + +1. Complexity of disk-based fs: disk-based filesystems such as ext2/ext3/ext4 + were designed for optimum performance on spinning disk media, so they + implement features such as block groups, which attempts to group inode data + into a contiguous set of data blocks to minimize disk seeking when accessing + files. For RAM there is no such concern; a file's data blocks can be + scattered throughout the media with no access speed penalty at all. So block + groups in a filesystem mounted over RAM just adds unnecessary + complexity. A better approach is to use a filesystem specifically + tailored to RAM media which does away with these disk-based features. + This increases the efficient use of space on the media, i.e. more + space is dedicated to actual file data storage and less to meta-data + needed to maintain that file data. + +2. Different problems between disks and RAM: Because PRAMFS attempts to avoid + filesystem corruption caused by kernel bugs, dirty pages in the page cache + are not allowed to be written back to the backing-store RAM. This way, an + errant write into the page cache will not get written back to the filesystem. + However, if the backing-store RAM is comparable in access speed to system + memory, the penalty of not using caching is minimal. With this consideration + it's better to move file data directly between the user buffers and the backing + store RAM, i.e. use direct I/O. This prevents the unnecessary populating of + the page cache with dirty pages. However direct I/O has to be enabled at + every file open. To enable direct I/O at all times for all regular files + requires either that applications be modified to include the O_DIRECT flag on + all file opens, or that the filesystem used performs direct I/O by default. + +The Persistent/Protected RAM Special Filesystem (PRAMFS) is a read/write +filesystem that has been designed to address these issues. PRAMFS is targeted +to fast I/O memory, and if the memory is non-volatile, the filesystem will be +persistent. + +In PRAMFS, direct I/O is enabled across all files in the filesystem, in other +words the O_DIRECT flag is forced on every open of a PRAMFS file. Also, file +I/O in the PRAMFS is always synchronous. There is no need to block the current +process while the transfer to/from the PRAMFS is in progress, since one of +the requirements of the PRAMFS is that the filesystem exists in fast RAM. So +file I/O in PRAMFS is always direct, synchronous, and never blocks. + +The data organization in PRAMFS can be thought of as an extremely simplified +version of ext2, such that the ratio of data to meta-data is very high. + +PRAMFS supports the execute-in-place. With XIP, instead of keeping data in the +page cache, the need to have a page cache copy is eliminated completely. +Readwrite type operations are performed directly from/to the memory. For file +mappings, the RAM itself is mapped directly into userspace. XIP, in addition, +speed up the applications start-up time because it removes the needs of any +copies. + +PRAMFS is write protected. The page table entries that map the backing-store +RAM are normally marked read-only. Write operations into the filesystem +temporarily mark the affected pages as writeable, the write operation is +carried out with locks held, and then the page table entries is +marked read-only again. +This feature provides protection against filesystem corruption caused by errant +writes into the RAM due to kernel
[PATCH 02/17] pramfs: super operations
From: Marco Stornelli marco.storne...@gmail.com
Super block operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/super.c b/fs/pramfs/super.c
new file mode 100644
index 000..0157b35
--- /dev/null
+++ b/fs/pramfs/super.c
@@ -0,0 +1,940 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Super block operations.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/module.h
+#include linux/string.h
+#include linux/slab.h
+#include linux/init.h
+#include linux/blkdev.h
+#include linux/parser.h
+#include linux/vfs.h
+#include linux/uaccess.h
+#include linux/io.h
+#include linux/seq_file.h
+#include linux/mount.h
+#include linux/mm.h
+#include linux/ctype.h
+#include linux/bitops.h
+#include linux/magic.h
+#include linux/exportfs.h
+#include linux/random.h
+#include xattr.h
+#include pram.h
+
+static struct super_operations pram_sops;
+static const struct export_operations pram_export_ops;
+static struct kmem_cache *pram_inode_cachep;
+
+#ifdef CONFIG_PRAMFS_TEST
+static void *first_pram_super;
+
+struct pram_super_block *get_pram_super(void)
+{
+ return (struct pram_super_block *)first_pram_super;
+}
+EXPORT_SYMBOL(get_pram_super);
+#endif
+
+void pram_error_mng(struct super_block * sb, const char * fmt, ...)
+{
+ va_list args;
+
+ va_start(args, fmt);
+ printk(KERN_ERR pramfs error: );
+ vprintk(fmt, args);
+ printk(\n);
+ va_end(args);
+
+ if (test_opt(sb, ERRORS_PANIC))
+ panic(pramfs: panic from previous error\n);
+ if (test_opt(sb, ERRORS_RO)) {
+ printk(KERN_CRIT pramfs error: remounting filesystem
read-only);
+ sb-s_flags |= MS_RDONLY;
+ }
+}
+
+static void pram_set_blocksize(struct super_block *sb, unsigned long size)
+{
+ int bits;
+
+ /*
+* We've already validated the user input and the value here must be
+* between PRAM_MAX_BLOCK_SIZE and PRAM_MIN_BLOCK_SIZE
+* and it must be a power of 2.
+*/
+ bits = fls(size) - 1;
+ sb-s_blocksize_bits = bits;
+ sb-s_blocksize = (1bits);
+}
+
+static inline void *pram_ioremap(phys_addr_t phys_addr, ssize_t size, bool
protect)
+{
+ void *retval;
+
+ /*
+* NOTE: Userland may not map this resource, we will mark the region so
+* /dev/mem and the sysfs MMIO access will not be allowed. This
+* restriction depends on STRICT_DEVMEM option. If this option is
+* disabled or not available we mark the region only as busy.
+*/
+ retval = request_mem_region_exclusive(phys_addr, size, pramfs);
+ if (!retval)
+ goto fail;
+
+ retval = ioremap_nocache(phys_addr, size);
+
+ if (retval protect)
+ pram_writeable(retval, size, 0);
+fail:
+ return retval;
+}
+
+static loff_t pram_max_size(int bits)
+{
+ loff_t res;
+ res = (1ULL (3*bits - 6)) - 1;
+
+ if (res MAX_LFS_FILESIZE)
+ res = MAX_LFS_FILESIZE;
+
+ pram_info(max file size %llu bytes\n, res);
+ return res;
+}
+
+enum {
+ Opt_addr, Opt_bpi, Opt_size,
+ Opt_num_inodes, Opt_mode, Opt_uid,
+ Opt_gid, Opt_blocksize, Opt_user_xattr,
+ Opt_nouser_xattr, Opt_noprotect,
+ Opt_acl, Opt_noacl, Opt_xip,
+ Opt_err_cont, Opt_err_panic, Opt_err_ro,
+ Opt_err
+};
+
+static const match_table_t tokens = {
+ {Opt_bpi, physaddr=%x},
+ {Opt_bpi, bpi=%u},
+ {Opt_size, init=%s},
+ {Opt_num_inodes,N=%u},
+ {Opt_mode, mode=%o},
+ {Opt_uid, uid=%u},
+ {Opt_gid, gid=%u},
+ {Opt_blocksize, bs=%s},
+ {Opt_user_xattr,user_xattr},
+ {Opt_user_xattr,nouser_xattr},
+ {Opt_noprotect, noprotect},
+ {Opt_acl, acl},
+ {Opt_acl, noacl},
+ {Opt_xip, xip},
+ {Opt_err_cont, errors=continue},
+ {Opt_err_panic, errors=panic},
+ {Opt_err_ro,errors=remount-ro},
+ {Opt_err, NULL},
+};
+
+static phys_addr_t get_phys_addr(void **data)
+{
+ phys_addr_t phys_addr;
+ char *options = (char *) *data;
+
+ if (!options || strncmp(options, physaddr=, 9) != 0)
+ return (phys_addr_t)ULLONG_MAX;
+ options += 9;
+ phys_addr = (phys_addr_t)simple_strtoull(options, options, 0);
+ if (*options *options != ',') {
+ printk(KERN_ERR Invalid phys addr
[PATCH 03/17] pramfs: inode operations
From: Marco Stornelli marco.storne...@gmail.com
Inode methods (allocate/free/read/write).
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/inode.c b/fs/pramfs/inode.c
new file mode 100644
index 000..e5ee072
--- /dev/null
+++ b/fs/pramfs/inode.c
@@ -0,0 +1,848 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Inode methods (allocate/free/read/write).
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/smp_lock.h
+#include linux/sched.h
+#include linux/highuid.h
+#include linux/module.h
+#include linux/mpage.h
+#include linux/backing-dev.h
+#include linux/falloc.h
+#include pram.h
+#include xattr.h
+#include xip.h
+#include acl.h
+
+struct backing_dev_info pram_backing_dev_info __read_mostly = {
+ .ra_pages = 0,/* No readahead */
+ .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK,
+};
+
+/*
+ * allocate a data block for inode and return it's absolute blocknr.
+ * Zeroes out the block if zero set. Increments inode-i_blocks.
+ */
+static int pram_new_data_block(struct inode *inode, unsigned long *blocknr,
+ int zero)
+{
+ int errval = pram_new_block(inode-i_sb, blocknr, zero);
+
+ if (!errval) {
+ struct pram_inode *pi = pram_get_inode(inode-i_sb,
+ inode-i_ino);
+ inode-i_blocks++;
+ pram_memunlock_inode(inode-i_sb, pi);
+ pi-i_blocks = cpu_to_be32(inode-i_blocks);
+ pram_memlock_inode(inode-i_sb, pi);
+ }
+
+ return errval;
+}
+
+/*
+ * find the offset to the block represented by the given inode's file
+ * relative block number.
+ */
+u64 pram_find_data_block(struct inode *inode, unsigned long file_blocknr)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *pi;
+ u64 *row; /* ptr to row block */
+ u64 *col; /* ptr to column blocks */
+ u64 bp = 0;
+ unsigned int i_row, i_col;
+ unsigned int N = sb-s_blocksize 3; /* num block ptrs per block */
+ unsigned int Nbits = sb-s_blocksize_bits - 3;
+
+ pi = pram_get_inode(sb, inode-i_ino);
+
+ i_row = file_blocknr Nbits;
+ i_col = file_blocknr (N-1);
+
+ row = pram_get_block(sb, be64_to_cpu(pi-i_type.reg.row_block));
+ if (row) {
+ col = pram_get_block(sb, be64_to_cpu(row[i_row]));
+ if (col)
+ bp = be64_to_cpu(col[i_col]);
+ }
+
+ return bp;
+}
+
+/*
+ * Free data blocks from inode in the range start = end
+ */
+static void __pram_truncate_blocks(struct inode *inode, loff_t start,
+ loff_t end)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *pi = pram_get_inode(sb, inode-i_ino);
+ int N = sb-s_blocksize 3; /* num block ptrs per block */
+ int Nbits = sb-s_blocksize_bits - 3;
+ int first_row_index, last_row_index, i, j;
+ unsigned long blocknr, first_blocknr, last_blocknr;
+ unsigned int freed = 0;
+ u64 *row; /* ptr to row block */
+ u64 *col; /* ptr to column blocks */
+
+ mutex_lock(PRAM_I(inode)-truncate_mutex);
+
+ if (start end || !inode-i_blocks || !pi-i_type.reg.row_block) {
+ mutex_unlock(PRAM_I(inode)-truncate_mutex);
+ return;
+ }
+
+ first_blocknr = (start + sb-s_blocksize - 1) sb-s_blocksize_bits;
+
+ if ((be32_to_cpu(pi-i_flags) PRAM_EOFBLOCKS_FL) start == 0)
+ last_blocknr = (1UL (2*sb-s_blocksize_bits - 6)) - 1;
+ else
+ last_blocknr = (end + sb-s_blocksize - 1)
+ sb-s_blocksize_bits;
+ first_row_index = first_blocknr Nbits;
+ last_row_index = last_blocknr Nbits;
+
+ row = pram_get_block(sb, be64_to_cpu(pi-i_type.reg.row_block));
+
+ for (i = first_row_index; i = last_row_index; i++) {
+ int first_col_index = (i == first_row_index) ?
+ first_blocknr (N-1) : 0;
+ int last_col_index = (i == last_row_index) ?
+ last_blocknr (N-1) : N-1;
+
+ if (unlikely(!row[i]))
+ continue;
+
+ col = pram_get_block(sb, be64_to_cpu(row[i]));
+
+ for (j = first_col_index; j = last_col_index; j++) {
+
+ if (unlikely(!col[j]))
+ continue;
+
+ blocknr = pram_get_blocknr(sb, be64_to_cpu(col[j
[PATCH 04/17] pramfs: file operations
From: Marco Stornelli marco.storne...@gmail.com
File operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/file.c b/fs/pramfs/file.c
new file mode 100644
index 000..05a4af4
--- /dev/null
+++ b/fs/pramfs/file.c
@@ -0,0 +1,326 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * File operations for files.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/sched.h
+#include linux/slab.h
+#include linux/uio.h
+#include linux/mm.h
+#include linux/uaccess.h
+#include pram.h
+#include acl.h
+#include xip.h
+#include xattr.h
+
+/*
+ * The following functions are helper routines to copy to/from
+ * user space and iter over io vectors (mainly for readv/writev).
+ * They are used in the direct IO path.
+ */
+static size_t __pram_iov_copy_from(char *vaddr,
+ const struct iovec *iov, size_t base, size_t bytes)
+{
+ size_t copied = 0, left = 0;
+
+ while (bytes) {
+ char __user *buf = iov-iov_base + base;
+ int copy = min(bytes, iov-iov_len - base);
+
+ base = 0;
+ left = __copy_from_user(vaddr, buf, copy);
+ copied += copy;
+ bytes -= copy;
+ vaddr += copy;
+ iov++;
+
+ if (unlikely(left))
+ break;
+ }
+ return copied - left;
+}
+
+static size_t __pram_iov_copy_to(char *vaddr,
+ const struct iovec *iov, size_t base, size_t bytes)
+{
+ size_t copied = 0, left = 0;
+
+ while (bytes) {
+ char __user *buf = iov-iov_base + base;
+ int copy = min(bytes, iov-iov_len - base);
+
+ base = 0;
+ left = __copy_to_user(buf, vaddr, copy);
+ copied += copy;
+ bytes -= copy;
+ vaddr += copy;
+ iov++;
+
+ if (unlikely(left))
+ break;
+ }
+ return copied - left;
+}
+
+static size_t pram_iov_copy_from(void *to, struct iov_iter *i, size_t bytes)
+{
+ size_t copied;
+
+ if (likely(i-nr_segs == 1)) {
+ int left;
+ char __user *buf = i-iov-iov_base + i-iov_offset;
+ left = __copy_from_user(to, buf, bytes);
+ copied = bytes - left;
+ } else {
+ copied = __pram_iov_copy_from(to, i-iov, i-iov_offset, bytes);
+ }
+
+ return copied;
+}
+
+static size_t pram_iov_copy_to(void *from, struct iov_iter *i, size_t bytes)
+{
+ size_t copied;
+
+ if (likely(i-nr_segs == 1)) {
+ int left;
+ char __user *buf = i-iov-iov_base + i-iov_offset;
+ left = __copy_to_user(buf, from, bytes);
+ copied = bytes - left;
+ } else {
+ copied = __pram_iov_copy_to(from, i-iov, i-iov_offset, bytes);
+ }
+
+ return copied;
+}
+
+static size_t __pram_clear_user(const struct iovec *iov, size_t base, size_t
bytes)
+{
+ size_t claened = 0, left = 0;
+
+ while (bytes) {
+ char __user *buf = iov-iov_base + base;
+ int clear = min(bytes, iov-iov_len - base);
+
+ base = 0;
+ left = __clear_user(buf, clear);
+ claened += clear;
+ bytes -= clear;
+ iov++;
+
+ if (unlikely(left))
+ break;
+ }
+ return claened - left;
+}
+
+static size_t pram_clear_user(struct iov_iter *i, size_t bytes)
+{
+ size_t clear;
+
+ if (likely(i-nr_segs == 1)) {
+ int left;
+ char __user *buf = i-iov-iov_base + i-iov_offset;
+ left = __clear_user(buf, bytes);
+ clear = bytes - left;
+ } else {
+ clear = __pram_clear_user(i-iov, i-iov_offset, bytes);
+ }
+
+ return clear;
+}
+
+static int pram_open_file(struct inode *inode, struct file *filp)
+{
+ filp-f_flags |= O_DIRECT;
+ return generic_file_open(inode, filp);
+}
+
+ssize_t pram_direct_IO(int rw, struct kiocb *iocb,
+ const struct iovec *iov,
+ loff_t offset, unsigned long nr_segs)
+{
+ struct file *file = iocb-ki_filp;
+ struct inode *inode = file-f_mapping-host;
+ struct super_block *sb = inode-i_sb;
+ int progress = 0, hole = 0, alloc_once = 1;
+ ssize_t retval = 0;
+ void *tmp = NULL;
+ unsigned long blocknr, blockoff, blocknr_start;
+ struct iov_iter iter;
+ int num_blocks, blocksize_mask
[PATCH 06/17] pramfs: inode operations for directories
From: Marco Stornelli marco.storne...@gmail.com
Inode operations for directories.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/namei.c b/fs/pramfs/namei.c
new file mode 100644
index 000..bedc43a
--- /dev/null
+++ b/fs/pramfs/namei.c
@@ -0,0 +1,371 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Inode operations for directories.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/fs.h
+#include linux/pagemap.h
+#include pram.h
+#include acl.h
+#include xattr.h
+#include xip.h
+
+/*
+ * Couple of helper functions - make the code slightly cleaner.
+ */
+
+static inline void pram_inc_count(struct inode *inode)
+{
+ inode-i_nlink++;
+ pram_write_inode(inode, 0);
+}
+
+static inline void pram_dec_count(struct inode *inode)
+{
+ if (inode-i_nlink) {
+ inode-i_nlink--;
+ pram_write_inode(inode, 0);
+ }
+}
+
+static inline int pram_add_nondir(struct inode *dir,
+ struct dentry *dentry,
+ struct inode *inode)
+{
+ int err = pram_add_link(dentry, inode);
+ if (!err) {
+ d_instantiate(dentry, inode);
+ unlock_new_inode(inode);
+ return 0;
+ }
+ pram_dec_count(inode);
+ unlock_new_inode(inode);
+ iput(inode);
+ return err;
+}
+
+/*
+ * Methods themselves.
+ */
+
+static ino_t
+pram_inode_by_name(struct inode *dir,
+ struct dentry *dentry)
+{
+ struct pram_inode *pi;
+ ino_t ino;
+ int namelen;
+
+ pi = pram_get_inode(dir-i_sb, dir-i_ino);
+ ino = be64_to_cpu(pi-i_type.dir.head);
+
+ while (ino) {
+ pi = pram_get_inode(dir-i_sb, ino);
+
+ if (pi-i_links_count) {
+ namelen = strlen(pi-i_d.d_name);
+
+ if (namelen == dentry-d_name.len
+ !memcmp(dentry-d_name.name,
+ pi-i_d.d_name, namelen))
+ break;
+ }
+
+ ino = be64_to_cpu(pi-i_d.d_next);
+ }
+
+ return ino;
+}
+
+static struct dentry *
+pram_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+{
+ struct inode *inode = NULL;
+ ino_t ino;
+
+ if (dentry-d_name.len PRAM_NAME_LEN)
+ return ERR_PTR(-ENAMETOOLONG);
+
+ ino = pram_inode_by_name(dir, dentry);
+ if (ino) {
+ inode = pram_iget(dir-i_sb, ino);
+ if (unlikely(IS_ERR(inode))) {
+ if (PTR_ERR(inode) == -ESTALE) {
+ pram_err(dir-i_sb, deleted inode referenced:
%lu,
+ (unsigned long) ino);
+ return ERR_PTR(-EIO);
+ } else {
+ return ERR_CAST(inode);
+ }
+ }
+ }
+
+ d_splice_alias(inode, dentry);
+ return NULL;
+}
+
+
+/*
+ * By the time this is called, we already have created
+ * the directory cache entry for the new file, but it
+ * is so far negative - it has no inode.
+ *
+ * If the create succeeds, we fill in the inode information
+ * with d_instantiate().
+ */
+static int pram_create(struct inode *dir, struct dentry *dentry,
+ int mode, struct nameidata *nd)
+{
+ struct inode *inode = pram_new_inode(dir, mode);
+ int err = PTR_ERR(inode);
+ if (!IS_ERR(inode)) {
+ inode-i_op = pram_file_inode_operations;
+ if (pram_use_xip(inode-i_sb)) {
+ inode-i_mapping-a_ops = pram_aops_xip;
+ inode-i_fop = pram_xip_file_operations;
+ } else {
+ inode-i_fop = pram_file_operations;
+ inode-i_mapping-a_ops = pram_aops;
+ }
+ err = pram_add_nondir(dir, dentry, inode);
+ }
+ return err;
+}
+
+static int pram_mknod(struct inode *dir, struct dentry *dentry, int mode,
+ dev_t rdev)
+{
+ struct inode *inode = pram_new_inode(dir, mode);
+ int err = PTR_ERR(inode);
+ if (!IS_ERR(inode)) {
+ init_special_inode(inode, mode, rdev);
+ pram_write_inode(inode, 0); /* update rdev */
+ err = pram_add_nondir(dir, dentry, inode);
+ }
+ return err;
+}
+
+static int pram_symlink(struct inode *dir,
+ struct dentry *dentry
[PATCH 08/17] pramfs: headers
From: Marco Stornelli marco.storne...@gmail.com
Definitions for the PRAMFS filesystem.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/pram.h b/fs/pramfs/pram.h
new file mode 100644
index 000..85169c4
--- /dev/null
+++ b/fs/pramfs/pram.h
@@ -0,0 +1,269 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Definitions for the PRAMFS filesystem.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#ifndef __PRAM_H
+#define __PRAM_H
+
+#include linux/buffer_head.h
+#include linux/pram_fs.h
+#include linux/pram_fs_sb.h
+#include linux/crc16.h
+#include linux/mutex.h
+#include linux/types.h
+#include wprotect.h
+
+/*
+ * Debug code
+ */
+#ifdef pr_fmt
+#undef pr_fmt
+#define pr_fmt(fmt) KBUILD_MODNAME : fmt
+#endif
+
+#define pram_dbg(s, args...) pr_debug(s, ## args)
+#define pram_err(sb, s, args...) pram_error_mng(sb, s, ## args)
+#define pram_warn(s, args...) pr_warning(s, ## args)
+#define pram_info(s, args...) pr_info(s, ## args)
+
+#define pram_set_bit ext2_set_bit
+#define pram_clear_bit ext2_clear_bit
+#define pram_find_next_zero_bitext2_find_next_zero_bit
+
+#define clear_opt(o, opt) (o = ~PRAM_MOUNT_##opt)
+#define set_opt(o, opt)(o |= PRAM_MOUNT_##opt)
+#define test_opt(sb, opt) \
+ (((struct pram_sb_info *)sb-s_fs_info)-s_mount_opt PRAM_MOUNT_##opt)
+
+/*
+ * Pram inode flags
+ *
+ * PRAM_EOFBLOCKS_FL There are blocks allocated beyond eof
+ */
+#define PRAM_EOFBLOCKS_FL 0x2000
+/* Flags that should be inherited by new inodes from their parent. */
+#define PRAM_FL_INHERITED (FS_SECRM_FL | FS_UNRM_FL | FS_COMPR_FL |\
+ FS_SYNC_FL | FS_IMMUTABLE_FL | FS_APPEND_FL |\
+ FS_NODUMP_FL | FS_NOATIME_FL | FS_COMPRBLK_FL|\
+ FS_NOCOMP_FL | FS_JOURNAL_DATA_FL |\
+ FS_NOTAIL_FL | FS_DIRSYNC_FL)
+/* Flags that are appropriate for regular files (all but dir-specific ones). */
+#define PRAM_REG_FLMASK (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
+/* Flags that are appropriate for non-directories/regular files. */
+#define PRAM_OTHER_FLMASK (FS_NODUMP_FL | FS_NOATIME_FL)
+
+/* Function Prototypes */
+extern void pram_error_mng(struct super_block * sb, const char * fmt, ...);
+extern int pram_get_and_update_block(struct inode *inode, sector_t iblock,
+struct buffer_head *bh, int create);
+
+static inline int pram_readpage(struct file *file, struct page *page)
+{
+ return block_read_full_page(page, pram_get_and_update_block);
+}
+
+/* file.c */
+extern ssize_t pram_direct_IO(int rw, struct kiocb *iocb,
+ const struct iovec *iov,
+ loff_t offset, unsigned long nr_segs);
+extern int pram_mmap(struct file *file, struct vm_area_struct *vma);
+
+/* balloc.c */
+extern void pram_init_bitmap(struct super_block *sb);
+extern void pram_free_block(struct super_block *sb, unsigned long blocknr);
+extern int pram_new_block(struct super_block *sb, unsigned long *blocknr, int
zero);
+extern unsigned long pram_count_free_blocks(struct super_block *sb);
+
+/* dir.c */
+extern int pram_add_link(struct dentry *dentry, struct inode *inode);
+extern int pram_remove_link(struct inode *inode);
+
+/* namei.c */
+extern struct dentry *pram_get_parent(struct dentry *child);
+
+/* inode.c */
+extern int pram_alloc_blocks(struct inode *inode, int file_blocknr,
+ unsigned int num);
+extern u64 pram_find_data_block(struct inode *inode,
+unsigned long file_blocknr);
+
+extern struct inode *pram_iget(struct super_block *sb, unsigned long ino);
+extern void pram_put_inode(struct inode *inode);
+extern void pram_evict_inode(struct inode *inode);
+extern struct inode *pram_new_inode(struct inode *dir, int mode);
+extern int pram_update_inode(struct inode *inode);
+extern int pram_write_inode(struct inode *inode, struct writeback_control
*wbc);
+extern void pram_dirty_inode(struct inode *inode);
+extern int pram_notify_change(struct dentry *dentry, struct iattr *attr);
+extern long pram_fallocate(struct inode *inode, int mode, loff_t offset,
+ loff_t len);
+extern void pram_set_inode_flags(struct inode *inode, struct pram_inode *pi);
+extern void pram_get_inode_flags(struct inode *inode, struct pram_inode *pi);
+
+/* ioctl.c */
+extern long pram_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
+#ifdef CONFIG_COMPAT
+extern long
[PATCH 09/17] pramfs: dir operations
From: Marco Stornelli marco.storne...@gmail.com
File operations for directories.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/dir.c b/fs/pramfs/dir.c
new file mode 100644
index 000..cf0bcba
--- /dev/null
+++ b/fs/pramfs/dir.c
@@ -0,0 +1,208 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * File operations for directories.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/pagemap.h
+#include pram.h
+
+/*
+ * Parent is locked.
+ */
+int pram_add_link(struct dentry *dentry, struct inode *inode)
+{
+ struct inode *dir = dentry-d_parent-d_inode;
+ struct pram_inode *pidir, *pi, *pitail = NULL;
+ u64 tail_ino, prev_ino;
+
+ const char *name = dentry-d_name.name;
+
+ int namelen = min_t(unsigned int, dentry-d_name.len, PRAM_NAME_LEN);
+
+ pidir = pram_get_inode(dir-i_sb, dir-i_ino);
+ pi = pram_get_inode(dir-i_sb, inode-i_ino);
+
+ dir-i_mtime = dir-i_ctime = CURRENT_TIME;
+
+ tail_ino = be64_to_cpu(pidir-i_type.dir.tail);
+ if (tail_ino != 0) {
+ pitail = pram_get_inode(dir-i_sb, tail_ino);
+ pram_memunlock_inode(dir-i_sb, pitail);
+ pitail-i_d.d_next = cpu_to_be64(inode-i_ino);
+ pram_memlock_inode(dir-i_sb, pitail);
+
+ prev_ino = tail_ino;
+
+ pram_memunlock_inode(dir-i_sb, pidir);
+ pidir-i_type.dir.tail = cpu_to_be64(inode-i_ino);
+ pidir-i_mtime = cpu_to_be32(dir-i_mtime.tv_sec);
+ pidir-i_ctime = cpu_to_be32(dir-i_ctime.tv_sec);
+ pram_memlock_inode(dir-i_sb, pidir);
+ } else {
+ /* the directory is empty */
+ prev_ino = 0;
+
+ pram_memunlock_inode(dir-i_sb, pidir);
+ pidir-i_type.dir.tail = cpu_to_be64(inode-i_ino);
+ pidir-i_type.dir.head = cpu_to_be64(inode-i_ino);
+ pidir-i_mtime = cpu_to_be32(dir-i_mtime.tv_sec);
+ pidir-i_ctime = cpu_to_be32(dir-i_ctime.tv_sec);
+ pram_memlock_inode(dir-i_sb, pidir);
+ }
+
+
+ pram_memunlock_inode(dir-i_sb, pi);
+ pi-i_d.d_prev = cpu_to_be64(prev_ino);
+ pi-i_d.d_parent = cpu_to_be64(dir-i_ino);
+ memcpy(pi-i_d.d_name, name, namelen);
+ pi-i_d.d_name[namelen] = '\0';
+ pram_memlock_inode(dir-i_sb, pi);
+ return 0;
+}
+
+int pram_remove_link(struct inode *inode)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *prev = NULL;
+ struct pram_inode *next = NULL;
+ struct pram_inode *pidir, *pi;
+
+ pi = pram_get_inode(sb, inode-i_ino);
+ pidir = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_parent));
+ if (!pidir)
+ return -EACCES;
+
+ if (inode-i_ino == be64_to_cpu(pidir-i_type.dir.head)) {
+ /* first inode in directory */
+ next = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_next));
+
+ if (next) {
+ pram_memunlock_inode(sb, next);
+ next-i_d.d_prev = 0;
+ pram_memlock_inode(sb, next);
+
+ pram_memunlock_inode(sb, pidir);
+ pidir-i_type.dir.head = pi-i_d.d_next;
+ } else {
+ pram_memunlock_inode(sb, pidir);
+ pidir-i_type.dir.head = 0;
+ pidir-i_type.dir.tail = 0;
+ }
+ pram_memlock_inode(sb, pidir);
+ } else if (inode-i_ino == be64_to_cpu(pidir-i_type.dir.tail)) {
+ /* last inode in directory */
+ prev = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_prev));
+
+ pram_memunlock_inode(sb, prev);
+ prev-i_d.d_next = 0;
+ pram_memlock_inode(sb, prev);
+
+ pram_memunlock_inode(sb, pidir);
+ pidir-i_type.dir.tail = pi-i_d.d_prev;
+ pram_memlock_inode(sb, pidir);
+ } else {
+ /* somewhere in the middle */
+ prev = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_prev));
+ next = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_next));
+
+ if (prev next) {
+ pram_memunlock_inode(sb, prev);
+ prev-i_d.d_next = pi-i_d.d_next;
+ pram_memlock_inode(sb, prev);
+
+ pram_memunlock_inode(sb, next);
+ next-i_d.d_prev = pi-i_d.d_prev;
+ pram_memlock_inode(sb, next
[PATCH 11/17] pramfs: ACL management
From: Marco Stornelli marco.storne...@gmail.com
ACL operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/acl.c b/fs/pramfs/acl.c
new file mode 100644
index 000..53090a5
--- /dev/null
+++ b/fs/pramfs/acl.c
@@ -0,0 +1,433 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * POSIX ACL operations
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * based on fs/ext2/acl.c with the following copyright:
+ *
+ * Copyright (C) 2001-2003 Andreas Gruenbacher, agr...@suse.de
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/capability.h
+#include linux/init.h
+#include linux/sched.h
+#include linux/slab.h
+#include linux/fs.h
+#include pram.h
+#include xattr.h
+#include acl.h
+
+/*
+ * Load ACL information from filesystem.
+ */
+static struct posix_acl *pram_acl_load(const void *value, size_t size)
+{
+ const char *end = (char *)value + size;
+ int n, count;
+ struct posix_acl *acl;
+
+ if (!value)
+ return NULL;
+ if (size sizeof(struct pram_acl_header))
+return ERR_PTR(-EINVAL);
+ if (((struct pram_acl_header *)value)-a_version !=
+ cpu_to_be32(PRAM_ACL_VERSION))
+ return ERR_PTR(-EINVAL);
+ value = (char *)value + sizeof(struct pram_acl_header);
+ count = pram_acl_count(size);
+ if (count 0)
+ return ERR_PTR(-EINVAL);
+ if (count == 0)
+ return NULL;
+ acl = posix_acl_alloc(count, GFP_KERNEL);
+ if (!acl)
+ return ERR_PTR(-ENOMEM);
+ for (n = 0; n count; n++) {
+ struct pram_acl_entry *entry = (struct pram_acl_entry *)value;
+ if ((char *)value + sizeof(struct pram_acl_entry_short) end)
+ goto fail;
+ acl-a_entries[n].e_tag = be16_to_cpu(entry-e_tag);
+ acl-a_entries[n].e_perm = be16_to_cpu(entry-e_perm);
+ switch (acl-a_entries[n].e_tag) {
+ case ACL_USER_OBJ:
+ case ACL_GROUP_OBJ:
+ case ACL_MASK:
+ case ACL_OTHER:
+ value = (char *)value +
+ sizeof(struct pram_acl_entry_short);
+ acl-a_entries[n].e_id = ACL_UNDEFINED_ID;
+ break;
+ case ACL_USER:
+ case ACL_GROUP:
+ value = (char *)value + sizeof(struct pram_acl_entry);
+ if ((char *)value end)
+ goto fail;
+ acl-a_entries[n].e_id =
+ be32_to_cpu(entry-e_id);
+ break;
+ default:
+ goto fail;
+ }
+ }
+ if (value != end)
+ goto fail;
+ return acl;
+
+fail:
+ posix_acl_release(acl);
+ return ERR_PTR(-EINVAL);
+}
+
+/*
+ * Save ACL information into the filesystem.
+ */
+static void *pram_acl_save(const struct posix_acl *acl, size_t *size)
+{
+ struct pram_acl_header *ext_acl;
+ char *e;
+ size_t n;
+
+ *size = pram_acl_size(acl-a_count);
+ ext_acl = kmalloc(sizeof(struct pram_acl_header) + acl-a_count *
+ sizeof(struct pram_acl_entry), GFP_KERNEL);
+ if (!ext_acl)
+ return ERR_PTR(-ENOMEM);
+ ext_acl-a_version = cpu_to_be32(PRAM_ACL_VERSION);
+ e = (char *)ext_acl + sizeof(struct pram_acl_header);
+ for (n = 0; n acl-a_count; n++) {
+ struct pram_acl_entry *entry = (struct pram_acl_entry *)e;
+ entry-e_tag = cpu_to_be16(acl-a_entries[n].e_tag);
+ entry-e_perm = cpu_to_be16(acl-a_entries[n].e_perm);
+ switch (acl-a_entries[n].e_tag) {
+ case ACL_USER:
+ case ACL_GROUP:
+ entry-e_id =
+ cpu_to_be32(acl-a_entries[n].e_id);
+ e += sizeof(struct pram_acl_entry);
+ break;
+ case ACL_USER_OBJ:
+ case ACL_GROUP_OBJ:
+ case ACL_MASK:
+ case ACL_OTHER:
+ e += sizeof(struct pram_acl_entry_short);
+ break;
+ default:
+ goto fail;
+ }
+ }
+ return (char *)ext_acl;
+
+fail:
+ kfree(ext_acl);
+ return ERR_PTR(-EINVAL);
+}
+
+/*
+ * inode-i_mutex: don't care
+ */
+static struct posix_acl *pram_get_acl(struct inode *inode, int type)
+{
+ int name_index;
+ char *value = NULL;
+ struct posix_acl *acl;
+ int retval;
+
+ if (!test_opt(inode-i_sb, POSIX_ACL))
+ return NULL;
+
+ acl = get_cached_acl(inode
[PATCH 12/17] pramfs: extended attributes
From: Marco Stornelli marco.storne...@gmail.com
Extended attributes operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/xattr.c b/fs/pramfs/xattr.c
new file mode 100644
index 000..44d158e
--- /dev/null
+++ b/fs/pramfs/xattr.c
@@ -0,0 +1,1104 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Extended attributes operations.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * based on fs/ext2/xattr.c with the following copyright:
+ *
+ * Fix by Harrison Xing harri...@mountainviewdata.com.
+ * Extended attributes for symlinks and special files added per
+ * suggestion of Luka Renko luka.re...@hermes.si.
+ * xattr consolidation Copyright (c) 2004 James Morris jmor...@redhat.com,
+ * Red Hat Inc.
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+/*
+ * Extended attributes are stored in blocks allocated outside of
+ * any inode. The i_xattr field is then made to point to this allocated
+ * block. If all extended attributes of an inode are identical, these
+ * inodes may share the same extended attribute block. Such situations
+ * are automatically detected by keeping a cache of recent attribute block
+ * numbers and hashes over the block's contents in memory.
+ *
+ *
+ * Extended attribute block layout:
+ *
+ * +--+
+ * | header |
+ * | entry 1 | |
+ * | entry 2 | | growing downwards
+ * | entry 3 | v
+ * | four null bytes |
+ * | . . .|
+ * | value 1 | ^
+ * | value 3 | | growing upwards
+ * | value 2 | |
+ * +--+
+ *
+ * The block header is followed by multiple entry descriptors. These entry
+ * descriptors are variable in size, and aligned to PRAM_XATTR_PAD
+ * byte boundaries. The entry descriptors are sorted by attribute name,
+ * so that two extended attribute blocks can be compared efficiently.
+ *
+ * Attribute values are aligned to the end of the block, stored in
+ * no specific order. They are also padded to PRAM_XATTR_PAD byte
+ * boundaries. No additional gaps are left between them.
+ *
+ * Locking strategy
+ *
+ * pi-i_xattr is protected by PRAM_I(inode)-xattr_sem.
+ * EA blocks are only changed if they are exclusive to an inode, so
+ * holding xattr_sem also means that nothing but the EA block's reference
+ * count will change. Multiple writers to an EA block are synchronized
+ * by the mutex in each block descriptor. Block descriptors are kept in a
+ * red black tree and the key is the absolute block number.
+ */
+
+#include linux/module.h
+#include linux/init.h
+#include linux/mbcache.h
+#include linux/rwsem.h
+#include linux/security.h
+#include pram.h
+#include xattr.h
+#include acl.h
+#include desctree.h
+
+#define HDR(bp) ((struct pram_xattr_header *)(bp))
+#define ENTRY(ptr) ((struct pram_xattr_entry *)(ptr))
+#define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1)
+#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
+#define GET_DESC(sbi, blocknr) lookup_xblock_desc(sbi, blocknr,
pram_xblock_desc_cache, 1)
+#define LOOKUP_DESC(sbi, blocknr) lookup_xblock_desc(sbi, blocknr, NULL, 0)
+
+#ifdef PRAM_XATTR_DEBUG
+# define ea_idebug(inode, f...) do { \
+ printk(KERN_DEBUG inode %ld: , inode-i_ino); \
+ printk(f); \
+ printk(\n); \
+ } while (0)
+# define ea_bdebug(blocknr, f...) do { \
+ printk(KERN_DEBUG block %lu: , blocknr); \
+ printk(f); \
+ printk(\n); \
+ } while (0)
+#else
+# define ea_idebug(f...)
+# define ea_bdebug(f...)
+#endif
+
+static int pram_xattr_set2(struct inode *, char *, struct pram_xblock_desc *,
struct pram_xattr_header *);
+
+static int pram_xattr_cache_insert(struct super_block *sb, unsigned long
blocknr, u32 xhash);
+static struct pram_xblock_desc *pram_xattr_cache_find(struct inode *,
+struct pram_xattr_header *);
+static void pram_xattr_rehash(struct pram_xattr_header *,
+ struct pram_xattr_entry *);
+
+static struct mb_cache *pram_xattr_cache;
+static struct kmem_cache *pram_xblock_desc_cache;
+
+static const struct xattr_handler *pram_xattr_handler_map[] = {
+ [PRAM_XATTR_INDEX_USER] = pram_xattr_user_handler,
+#ifdef CONFIG_PRAMFS_POSIX_ACL
+ [PRAM_XATTR_INDEX_POSIX_ACL_ACCESS] = pram_xattr_acl_access_handler,
+ [PRAM_XATTR_INDEX_POSIX_ACL_DEFAULT] = pram_xattr_acl_default_handler,
+#endif
+ [PRAM_XATTR_INDEX_TRUSTED] = pram_xattr_trusted_handler,
+#ifdef CONFIG_PRAMFS_SECURITY
+ [PRAM_XATTR_INDEX_SECURITY] = pram_xattr_security_handler,
+#endif
+};
+
+const struct xattr_handler *pram_xattr_handlers[] = {
+ pram_xattr_user_handler,
+ pram_xattr_trusted_handler,
+#ifdef
[PATCH 13/17] pramfs: extended attributes block descriptors tree
From: Marco Stornelli marco.storne...@gmail.com
Extended attributes block descriptors tree.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/desctree.c b/fs/pramfs/desctree.c
new file mode 100644
index 000..4508e70
--- /dev/null
+++ b/fs/pramfs/desctree.c
@@ -0,0 +1,181 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Extended attributes block descriptors tree.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/spinlock.h
+#include desctree.h
+#include pram.h
+
+/* xblock_desc_init_always()
+ *
+ * These are initializations that need to be done on every
+ * descriptor allocation as the fields are not initialised
+ * by slab allocation.
+ */
+void xblock_desc_init_always(struct pram_xblock_desc *desc)
+{
+ atomic_set(desc-refcount, 0);
+ desc-blocknr = 0;
+ desc-flags = 0;
+}
+
+/* xblock_desc_init_once()
+ *
+ * These are initializations that only need to be done
+ * once, because the fields are idempotent across use
+ * of the descriptor, so let the slab aware of that.
+ */
+void xblock_desc_init_once(struct pram_xblock_desc *desc)
+{
+ mutex_init(desc-lock);
+}
+
+/* __insert_xblock_desc()
+ *
+ * Insert a new descriptor in the tree.
+ */
+static void __insert_xblock_desc(struct pram_sb_info *sbi,
+unsigned long blocknr, struct rb_node *node)
+{
+ struct rb_node **p = (sbi-desc_tree.rb_node);
+ struct rb_node *parent = NULL;
+ struct pram_xblock_desc *desc;
+
+ while (*p) {
+ parent = *p;
+ desc = rb_entry(parent, struct pram_xblock_desc, node);
+
+ if (blocknr desc-blocknr)
+ p = (*p)-rb_left;
+ else if (blocknr desc-blocknr)
+ p = (*p)-rb_right;
+ else
+ /* Oops...an other descriptor for the same block ? */
+ BUG();
+ }
+
+ rb_link_node(node, parent, p);
+ rb_insert_color(node, sbi-desc_tree);
+}
+
+void insert_xblock_desc(struct pram_sb_info *sbi, struct pram_xblock_desc
*desc)
+{
+ spin_lock(sbi-desc_tree_lock);
+ __insert_xblock_desc(sbi, desc-blocknr, desc-node);
+ spin_unlock(sbi-desc_tree_lock);
+};
+
+/* __lookup_xblock_desc()
+ *
+ * Search an extended attribute descriptor in the tree via the
+ * block number. It returns the descriptor if it's found or
+ * NULL. If not found it creates a new descriptor if create is not 0.
+ */
+static struct pram_xblock_desc *__lookup_xblock_desc(struct pram_sb_info *sbi,
+ unsigned long blocknr,
+ struct kmem_cache *cache,
+ int create)
+{
+ struct rb_node *n = sbi-desc_tree.rb_node;
+ struct pram_xblock_desc *desc = NULL;
+
+ while (n) {
+ desc = rb_entry(n, struct pram_xblock_desc, node);
+
+ if (blocknr desc-blocknr)
+ n = n-rb_left;
+ else if (blocknr desc-blocknr)
+ n = n-rb_right;
+ else {
+ atomic_inc(desc-refcount);
+ goto out;
+ }
+ }
+
+ /* not found */
+ if (create) {
+ desc = kmem_cache_alloc(cache, GFP_NOFS);
+ if (!desc)
+ return ERR_PTR(-ENOMEM);
+ xblock_desc_init_always(desc);
+ atomic_set(desc-refcount, 1);
+ desc-blocknr = blocknr;
+ __insert_xblock_desc(sbi, desc-blocknr, desc-node);
+ }
+out:
+ return desc;
+}
+
+struct pram_xblock_desc *lookup_xblock_desc(struct pram_sb_info *sbi,
+ unsigned long blocknr,
+ struct kmem_cache *cache,
+ int create)
+{
+ struct pram_xblock_desc *desc = NULL;
+
+ spin_lock(sbi-desc_tree_lock);
+ desc = __lookup_xblock_desc(sbi, blocknr, cache, create);
+ spin_unlock(sbi-desc_tree_lock);
+ return desc;
+}
+
+/* put_xblock_desc()
+ *
+ * Decrement the reference count and if it reaches zero and the
+ * desciptor has been marked to be free, then we free it.
+ * It returns 0 if the descriptor has been deleted and 1 otherwise.
+ */
+int put_xblock_desc(struct pram_sb_info *sbi, struct pram_xblock_desc *desc)
+{
+ int ret = 1;
+ if (!desc)
+ return ret;
+
+ if (atomic_dec_and_lock(desc-refcount, sbi-desc_tree_lock)) {
+ if (test_bit(FREEING, desc-flags)) {
+ rb_erase(desc-node, sbi-desc_tree);
+ pram_dbg(erasing desc
[PATCH 14/17] pramfs: memory protection
From: Marco Stornelli marco.storne...@gmail.com
Memory write protection.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/wprotect.c b/fs/pramfs/wprotect.c
new file mode 100644
index 000..d0f0508
--- /dev/null
+++ b/fs/pramfs/wprotect.c
@@ -0,0 +1,41 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Write protection for the filesystem pages.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/module.h
+#include linux/fs.h
+#include linux/mm.h
+#include linux/io.h
+#include pram.h
+
+DEFINE_SPINLOCK(writeable_lock);
+
+void pram_writeable(void *vaddr, unsigned long size, int rw)
+{
+ int ret = 0;
+ unsigned long nrpages = size PAGE_SHIFT;
+ unsigned long addr = (unsigned long)vaddr;
+
+ /* Page aligned */
+ addr = PAGE_MASK;
+
+ if (size (PAGE_SIZE - 1))
+ nrpages++;
+
+ if (rw)
+ ret = set_memory_rw(addr, nrpages);
+ else
+ ret = set_memory_ro(addr, nrpages);
+
+ BUG_ON(ret);
+}
diff --git a/fs/pramfs/wprotect.h b/fs/pramfs/wprotect.h
new file mode 100644
index 000..0aa1e33
--- /dev/null
+++ b/fs/pramfs/wprotect.h
@@ -0,0 +1,151 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Memory protection definitions for the PRAMFS filesystem.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef __WPROTECT_H
+#define __WPROTECT_H
+
+#include linux/pram_fs.h
+
+/* pram_memunlock_super() before calling! */
+static inline void pram_sync_super(struct pram_super_block *ps)
+{
+ u16 crc = 0;
+ ps-s_wtime = cpu_to_be32(get_seconds());
+ ps-s_sum = 0;
+ crc = crc16(~0, (__u8 *)ps + sizeof(__be16), PRAM_SB_SIZE -
sizeof(__be16));
+ ps-s_sum = cpu_to_be16(crc);
+ /* Keep sync redundant super block */
+ memcpy((void *)ps + PRAM_SB_SIZE, (void *)ps, PRAM_SB_SIZE);
+}
+
+/* pram_memunlock_inode() before calling! */
+static inline void pram_sync_inode(struct pram_inode *pi)
+{
+ u16 crc = 0;
+ pi-i_sum = 0;
+ crc = crc16(~0, (__u8 *)pi + sizeof(__be16), PRAM_INODE_SIZE -
sizeof(__be16));
+ pi-i_sum = cpu_to_be16(crc);
+}
+
+#ifdef CONFIG_PRAMFS_WRITE_PROTECT
+extern void pram_writeable(void *vaddr, unsigned long size, int rw);
+extern spinlock_t writeable_lock;
+static inline int pram_is_protected(struct super_block *sb)
+{
+ struct pram_sb_info *sbi = (struct pram_sb_info *)sb-s_fs_info;
+ return sbi-s_mount_opt PRAM_MOUNT_PROTECT;
+}
+
+static inline void __pram_memunlock_range(void *p, unsigned long len)
+{
+ /* + * NOTE: Ideally we should lock all the kernel to be memory safe
+* and avoid to write in the protected memory,
+* obviously it's not possible, so we only serialize
+* the operations at fs level. We can't disable the interrupts
+* because we could have a deadlock in this path.
+*/
+ spin_lock(writeable_lock);
+ pram_writeable(p, len, 1);
+}
+
+static inline void __pram_memlock_range(void *p, unsigned long len)
+{
+ pram_writeable(p, len, 0);
+ spin_unlock(writeable_lock);
+}
+
+static inline void pram_memunlock_range(struct super_block *sb, void *p,
+ unsigned long len)
+{
+ if (pram_is_protected(sb))
+ __pram_memunlock_range(p, len);
+}
+
+static inline void pram_memlock_range(struct super_block *sb, void *p,
+ unsigned long len)
+{
+ if (pram_is_protected(sb))
+ __pram_memlock_range(p, len);
+}
+
+static inline void pram_memunlock_super(struct super_block *sb,
+ struct pram_super_block *ps)
+{
+ if (pram_is_protected(sb))
+ __pram_memunlock_range(ps, PRAM_SB_SIZE);
+}
+
+static inline void pram_memlock_super(struct super_block *sb,
+ struct pram_super_block *ps)
+{
+ pram_sync_super(ps);
+ if (pram_is_protected(sb))
+ __pram_memlock_range(ps, PRAM_SB_SIZE);
+}
+
+static inline void pram_memunlock_inode(struct super_block *sb,
+ struct pram_inode *pi)
+{
+ if (pram_is_protected(sb))
+ __pram_memunlock_range(pi, PRAM_SB_SIZE);
+}
+
+static inline void pram_memlock_inode(struct super_block *sb,
+ struct pram_inode *pi
[PATCH 15/17] pramfs: test module
From: Marco Stornelli marco.storne...@gmail.com
Test module.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff --git a/fs/pramfs/pramfs_test.c b/fs/pramfs/pramfs_test.c
new file mode 100644
index 000..24e016f
--- /dev/null
+++ b/fs/pramfs/pramfs_test.c
@@ -0,0 +1,47 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Pramfs test module.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/module.h
+#include linux/version.h
+#include linux/init.h
+#include linux/fs.h
+#include pram.h
+
+int __init test_pramfs_write(void)
+{
+ struct pram_super_block *psb;
+
+ psb = get_pram_super();
+ if (!psb) {
+ printk(KERN_ERR
+ %s: PRAMFS super block not found (not mounted?)\n,
+ __func__);
+ return 1;
+ }
+
+ /*
+* Attempt an unprotected clear of checksum information in the
+* superblock, this should cause a kernel page protection fault.
+*/
+ printk(%s: writing to kernel VA %p\n, __func__, psb);
+ psb-s_sum = 0;
+
+ return 0;
+}
+
+void test_pramfs_write_cleanup(void) {}
+
+/* Module information */
+MODULE_LICENSE(GPL);
+module_init(test_pramfs_write);
+module_exit(test_pramfs_write_cleanup);
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 00/17] pramfs: persistent and protected RAM filesystem
Il 06/01/2011 15:03, Peter Zijlstra ha scritto: On Thu, 2011-01-06 at 13:00 +0100, Marco Stornelli wrote: Hi all, after several reviews is time to submit the code for mainline. Thanks to CELF to believe and support actively the project and thanks to Tim Bird. Tony Luck was also playing with something like this I believe. Yes, I know. Even if the approach is different. He is trying to use a persistent space record-based and with a simple fs interface to store oops or something like this. The idea here is a little bit different, i.e. to have a place (a generic piece of memory) to write not sensible and temporary information with a complete fs structure. However we are on the same road :) Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 00/17] pramfs: persistent and protected RAM filesystem
Il 06/01/2011 19:22, Luck, Tony ha scritto: Errata corrige: maybe I used the wrong term, I meant volatile instead of temporary information, i.e. I'd like to save this info to re-read it later but I don't want to store it in flash, a simple log, run-time information for debug like a flight-recorder or whatever you want. I'm puzzled by the use of a generic piece of memory to store persistent things (Perhaps this is made clear in the 17 parts of the patch? I haven't read them yet). On x86 f/w typically clears all of memory on reset ... so you only get persistence if you use kexec to get from the old kernel to the new one. -Tony First of all, you can find a lot of information on the web site where there is an overview and a page with implementation details, benchmark and so on. With a generic piece of memory I mean a generic memory device directly addressable. Usually this generic device is an NVRAM, so we have a persistent store. If you haven't got this hw you can use other devices or the classic RAM, in this case you have a fs persistent only over reboot. The use of this fs is mainly for embedded systems, fw can be configured to not clear *all* the memory. Pramfs is indeed supported by U-Boot, you can see CONFIG_PRAM in the Das U-Boot manual. x86 in this case can be a strange world for this fs, but however if the user wants it can be used without problems because there aren't neither strict arch or hw dependency. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 00/16 v5] pramfs: persistent and protected RAM filesystem
Hi all,
fifth round for the patch series. I summarize here the changes to
improve the review:
v5:
- removed the changelog from documentation file
- added the function pram_check_flags in the file operations
- added a check when the user uses XIP and the blocksize is different
from page size
- added i_meta_mutex to avoid race conditions in the inode update
path
- changed the lock policy during mem{lock|unlock} operations
- replaced bitmap_set with bitmap_fill
- added mount options xip, acl, noacl, noprotect, user_xattr and
nouser_xattr as required by Paul Maundt
- inserted pr_fmt in pram.h
- inserted macros IF2DT and DT2IF
- removed file name description from each file
- used min_t instead of using own check in pram_add_link()
v4:
- in bitmap init used already present bitmap_set function
- fix a possible memory leak in an error path reported by yidong zhang
v3:
- fix a possible memory leak in an error path reported by yidong zhang
- fix a warning when using XIP about not used __pram_mmap symbol
- fix test module header description and replaced TEST_MODULE with
PRAMFS_TEST_MODULE in the Kconfig and Makefile according to the comments
done by Randy Dunlap
- fix a compilation warning in super.c reported by James Hogan
- fix a compilation error when XIP was enabled
- removed not used symbol PRAM_XATTR_INDEX_LUSTRE
- fix some comment style issue
v2:
- fix documentation errors reported by Randy Dunlap and Kieran Bingham
- reworked memory write protection functions with the suggestions of
Andi Kleen
v1:
- first draft
Marco
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 03/16 v5] pramfs: inode operations
From: Marco Stornelli marco.storne...@gmail.com
Inode methods (allocate/free/read/write).
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/inode.c linux-2.6.36/fs/pramfs/inode.c
--- linux-2.6.36-orig/fs/pramfs/inode.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/inode.c 2010-12-15 19:24:14.0 +0100
@@ -0,0 +1,729 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Inode methods (allocate/free/read/write).
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/smp_lock.h
+#include linux/sched.h
+#include linux/highuid.h
+#include linux/quotaops.h
+#include linux/module.h
+#include linux/mpage.h
+#include linux/backing-dev.h
+#include pram.h
+#include xattr.h
+#include xip.h
+#include acl.h
+
+struct backing_dev_info pram_backing_dev_info __read_mostly = {
+ .ra_pages = 0,/* No readahead */
+ .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK,
+};
+
+/*
+ * allocate a data block for inode and return it's absolute blocknr.
+ * Zeroes out the block if zero set. Increments inode-i_blocks.
+ */
+static int pram_new_data_block(struct inode *inode, unsigned long *blocknr,
int zero)
+{
+ int errval = pram_new_block(inode-i_sb, blocknr, zero);
+
+ if (!errval) {
+ struct pram_inode *pi = pram_get_inode(inode-i_sb,
+ inode-i_ino);
+ inode-i_blocks++;
+ pram_memunlock_inode(inode-i_sb, pi);
+ pi-i_blocks = cpu_to_be32(inode-i_blocks);
+ pram_memlock_inode(inode-i_sb, pi);
+ }
+
+ return errval;
+}
+
+/*
+ * find the offset to the block represented by the given inode's file
+ * relative block number.
+ */
+u64 pram_find_data_block(struct inode *inode, unsigned long file_blocknr)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *pi;
+ u64 *row; /* ptr to row block */
+ u64 *col; /* ptr to column blocks */
+ u64 bp = 0;
+ unsigned int i_row, i_col;
+ unsigned int N = sb-s_blocksize 3; /* num block ptrs per block */
+ unsigned int Nbits = sb-s_blocksize_bits - 3;
+
+ pi = pram_get_inode(sb, inode-i_ino);
+
+ i_row = file_blocknr Nbits;
+ i_col = file_blocknr (N-1);
+
+ row = pram_get_block(sb, be64_to_cpu(pi-i_type.reg.row_block));
+ if (row) {
+ col = pram_get_block(sb, be64_to_cpu(row[i_row]));
+ if (col)
+ bp = be64_to_cpu(col[i_col]);
+ }
+
+ return bp;
+}
+
+/*
+ * Free data blocks from inode in the range start = end
+ */
+static void __pram_truncate_blocks(struct inode *inode, loff_t start, loff_t
end)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *pi = pram_get_inode(sb, inode-i_ino);
+ int N = sb-s_blocksize 3; /* num block ptrs per block */
+ int Nbits = sb-s_blocksize_bits - 3;
+ int first_row_index, last_row_index, i, j;
+ unsigned long blocknr, first_blocknr, last_blocknr;
+ unsigned int freed = 0;
+ u64 *row; /* ptr to row block */
+ u64 *col; /* ptr to column blocks */
+
+ if (start end || !inode-i_blocks || !pi-i_type.reg.row_block)
+ return;
+
+ mutex_lock(PRAM_I(inode)-truncate_mutex);
+
+ first_blocknr = (start + sb-s_blocksize - 1) sb-s_blocksize_bits;
+ last_blocknr = (end + sb-s_blocksize - 1) sb-s_blocksize_bits;
+ first_row_index = first_blocknr Nbits;
+ last_row_index = last_blocknr Nbits;
+
+ row = pram_get_block(sb, be64_to_cpu(pi-i_type.reg.row_block));
+
+ for (i = first_row_index; i = last_row_index; i++) {
+ int first_col_index = (i == first_row_index) ?
+ first_blocknr (N-1) : 0;
+ int last_col_index = (i == last_row_index) ?
+ last_blocknr (N-1) : N-1;
+
+ if (unlikely(!row[i]))
+ continue;
+
+ col = pram_get_block(sb, be64_to_cpu(row[i]));
+
+ for (j = first_col_index; j = last_col_index; j++) {
+
+ if (unlikely(!col[j]))
+ continue;
+
+ blocknr = pram_get_blocknr(sb, be64_to_cpu(col[j]));
+ pram_free_block(sb, blocknr);
+ freed++;
+ pram_memunlock_block(sb, col);
+ col[j] = 0;
+ pram_memlock_block(sb, col
[PATCH 05/16 v5] pramfs: block allocation
From: Marco Stornelli marco.storne...@gmail.com
Block allocation operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/balloc.c linux-2.6.36/fs/pramfs/balloc.c
--- linux-2.6.36-orig/fs/pramfs/balloc.c1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/balloc.c 2010-12-12 17:19:21.0 +0100
@@ -0,0 +1,147 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * The blocks allocation and deallocation routines.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/bitops.h
+#include pram.h
+
+/*
+ * This just marks in-use the blocks that make up the bitmap.
+ * The bitmap must be writeable before calling.
+ */
+void pram_init_bitmap(struct super_block *sb)
+{
+ struct pram_super_block *ps = pram_get_super(sb);
+ unsigned long *bitmap = pram_get_bitmap(sb);
+ int blocks = be32_to_cpu(ps-s_bitmap_blocks);
+
+ memset(bitmap, 0, blocks sb-s_blocksize_bits);
+
+ bitmap_fill(bitmap, blocks);
+}
+
+
+/* Free absolute blocknr */
+void pram_free_block(struct super_block *sb, unsigned long blocknr)
+{
+ struct pram_super_block *ps;
+ u64 bitmap_block;
+ unsigned long bitmap_bnr;
+ void *bitmap;
+ void *bp;
+
+ lock_super(sb);
+
+ bitmap = pram_get_bitmap(sb);
+ /*
+* find the block within the bitmap that contains the inuse bit
+* for the block we need to free. We need to unlock this bitmap
+* block to clear the inuse bit.
+*/
+ bitmap_bnr = blocknr (3 + sb-s_blocksize_bits);
+ bitmap_block = pram_get_block_off(sb, bitmap_bnr);
+ bp = pram_get_block(sb, bitmap_block);
+
+ pram_memunlock_block(sb, bp);
+ pram_clear_bit(blocknr, bitmap); /* mark the block free */
+ pram_memlock_block(sb, bp);
+
+ ps = pram_get_super(sb);
+ pram_memunlock_super(sb, ps);
+
+ if (blocknr be32_to_cpu(ps-s_free_blocknr_hint))
+ ps-s_free_blocknr_hint = cpu_to_be32(blocknr);
+ be32_add_cpu(ps-s_free_blocks_count, 1);
+ pram_memlock_super(sb, ps);
+
+ unlock_super(sb);
+}
+
+
+/*
+ * allocate a block and return it's absolute blocknr. Zeroes out the
+ * block if zero set.
+ */
+int pram_new_block(struct super_block *sb, unsigned long *blocknr, int zero)
+{
+ struct pram_super_block *ps;
+ u64 bitmap_block;
+ unsigned long bnr, bitmap_bnr;
+ int errval;
+ void *bitmap;
+ void *bp;
+
+ lock_super(sb);
+ ps = pram_get_super(sb);
+ bitmap = pram_get_bitmap(sb);
+
+ if (ps-s_free_blocks_count) {
+ /* find the oldest unused block */
+ bnr = pram_find_next_zero_bit(bitmap,
+be32_to_cpu(ps-s_blocks_count),
+be32_to_cpu(ps-s_free_blocknr_hint));
+
+ if (bnr be32_to_cpu(ps-s_bitmap_blocks) ||
+ bnr = be32_to_cpu(ps-s_blocks_count)) {
+ pram_dbg(no free blocks found!\n);
+ errval = -ENOSPC;
+ goto fail;
+ }
+
+ pram_memunlock_super(sb, ps);
+ be32_add_cpu(ps-s_free_blocks_count, -1);
+ if (bnr (be32_to_cpu(ps-s_blocks_count)-1))
+ ps-s_free_blocknr_hint = cpu_to_be32(bnr+1);
+ else
+ ps-s_free_blocknr_hint = 0;
+ pram_memlock_super(sb, ps);
+ } else {
+ pram_dbg(all blocks allocated\n);
+ errval = -ENOSPC;
+ goto fail;
+ }
+
+ /*
+* find the block within the bitmap that contains the inuse bit
+* for the unused block we just found. We need to unlock it to
+* set the inuse bit.
+*/
+ bitmap_bnr = bnr (3 + sb-s_blocksize_bits);
+ bitmap_block = pram_get_block_off(sb, bitmap_bnr);
+ bp = pram_get_block(sb, bitmap_block);
+
+ pram_memunlock_block(sb, bp);
+ pram_set_bit(bnr, bitmap); /* mark the new block in use */
+ pram_memlock_block(sb, bp);
+
+ if (zero) {
+ bp = pram_get_block(sb, pram_get_block_off(sb, bnr));
+ pram_memunlock_block(sb, bp);
+ memset(bp, 0, sb-s_blocksize);
+ pram_memlock_block(sb, bp);
+ }
+
+ *blocknr = bnr;
+ pram_dbg(allocated blocknr %lu, bnr);
+ errval = 0;
+ fail:
+ unlock_super(sb);
+ return errval;
+}
+
+unsigned long
[PATCH 12/16 v5] pramfs: extended attributes management
From: Marco Stornelli marco.storne...@gmail.com
Extended attributes operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/xattr.c linux-2.6.36/fs/pramfs/xattr.c
--- linux-2.6.36-orig/fs/pramfs/xattr.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/xattr.c 2010-11-28 17:51:11.0 +0100
@@ -0,0 +1,1104 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Extended attributes operations.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * based on fs/ext2/xattr.c with the following copyright:
+ *
+ * Fix by Harrison Xing harri...@mountainviewdata.com.
+ * Extended attributes for symlinks and special files added per
+ * suggestion of Luka Renko luka.re...@hermes.si.
+ * xattr consolidation Copyright (c) 2004 James Morris jmor...@redhat.com,
+ * Red Hat Inc.
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+/*
+ * Extended attributes are stored in blocks allocated outside of
+ * any inode. The i_xattr field is then made to point to this allocated
+ * block. If all extended attributes of an inode are identical, these
+ * inodes may share the same extended attribute block. Such situations
+ * are automatically detected by keeping a cache of recent attribute block
+ * numbers and hashes over the block's contents in memory.
+ *
+ *
+ * Extended attribute block layout:
+ *
+ * +--+
+ * | header |
+ * | entry 1 | |
+ * | entry 2 | | growing downwards
+ * | entry 3 | v
+ * | four null bytes |
+ * | . . .|
+ * | value 1 | ^
+ * | value 3 | | growing upwards
+ * | value 2 | |
+ * +--+
+ *
+ * The block header is followed by multiple entry descriptors. These entry
+ * descriptors are variable in size, and alligned to PRAM_XATTR_PAD
+ * byte boundaries. The entry descriptors are sorted by attribute name,
+ * so that two extended attribute blocks can be compared efficiently.
+ *
+ * Attribute values are aligned to the end of the block, stored in
+ * no specific order. They are also padded to PRAM_XATTR_PAD byte
+ * boundaries. No additional gaps are left between them.
+ *
+ * Locking strategy
+ *
+ * pi-i_xattr is protected by PRAM_I(inode)-xattr_sem.
+ * EA blocks are only changed if they are exclusive to an inode, so
+ * holding xattr_sem also means that nothing but the EA block's reference
+ * count will change. Multiple writers to an EA block are synchronized
+ * by the mutex in each block descriptor. Block descriptors are kept in a
+ * red black tree and the key is the absolute block number.
+ */
+
+#include linux/module.h
+#include linux/init.h
+#include linux/mbcache.h
+#include linux/rwsem.h
+#include linux/security.h
+#include pram.h
+#include xattr.h
+#include acl.h
+#include desctree.h
+
+#define HDR(bp) ((struct pram_xattr_header *)(bp))
+#define ENTRY(ptr) ((struct pram_xattr_entry *)(ptr))
+#define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1)
+#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
+#define GET_DESC(sbi, blocknr) lookup_xblock_desc(sbi, blocknr,
pram_xblock_desc_cache, 1)
+#define LOOKUP_DESC(sbi, blocknr) lookup_xblock_desc(sbi, blocknr, NULL, 0)
+
+#ifdef PRAM_XATTR_DEBUG
+# define ea_idebug(inode, f...) do { \
+ printk(KERN_DEBUG inode %ld: , inode-i_ino); \
+ printk(f); \
+ printk(\n); \
+ } while (0)
+# define ea_bdebug(blocknr, f...) do { \
+ printk(KERN_DEBUG block %lu: , blocknr); \
+ printk(f); \
+ printk(\n); \
+ } while (0)
+#else
+# define ea_idebug(f...)
+# define ea_bdebug(f...)
+#endif
+
+static int pram_xattr_set2(struct inode *, char *, struct pram_xblock_desc *,
struct pram_xattr_header *);
+
+static int pram_xattr_cache_insert(struct super_block *sb, unsigned long
blocknr, u32 xhash);
+static struct pram_xblock_desc *pram_xattr_cache_find(struct inode *,
+struct pram_xattr_header *);
+static void pram_xattr_rehash(struct pram_xattr_header *,
+ struct pram_xattr_entry *);
+
+static struct mb_cache *pram_xattr_cache;
+static struct kmem_cache *pram_xblock_desc_cache;
+
+static const struct xattr_handler *pram_xattr_handler_map[] = {
+ [PRAM_XATTR_INDEX_USER] = pram_xattr_user_handler,
+#ifdef CONFIG_PRAMFS_POSIX_ACL
+ [PRAM_XATTR_INDEX_POSIX_ACL_ACCESS] = pram_xattr_acl_access_handler,
+ [PRAM_XATTR_INDEX_POSIX_ACL_DEFAULT] = pram_xattr_acl_default_handler,
+#endif
+ [PRAM_XATTR_INDEX_TRUSTED] = pram_xattr_trusted_handler,
+#ifdef CONFIG_PRAMFS_SECURITY
+ [PRAM_XATTR_INDEX_SECURITY] = pram_xattr_security_handler,
+#endif
+};
+
+const struct xattr_handler
[PATCH 16/16 v5] pramfs: Makefile and Kconfig
From: Marco Stornelli marco.storne...@gmail.com Makefile and Kconfig. Signed-off-by: Marco Stornelli marco.storne...@gmail.com --- diff -Nurp linux-2.6.36-orig/fs/Makefile linux-2.6.36/fs/Makefile --- linux-2.6.36-orig/fs/Makefile 2010-09-13 01:07:37.0 +0200 +++ linux-2.6.36/fs/Makefile2010-09-14 18:49:52.0 +0200 @@ -126,3 +126,4 @@ obj-$(CONFIG_BTRFS_FS) += btrfs/ obj-$(CONFIG_GFS2_FS) += gfs2/ obj-$(CONFIG_EXOFS_FS) += exofs/ obj-$(CONFIG_CEPH_FS) += ceph/ +obj-$(CONFIG_PRAMFS) += pramfs/ diff -Nurp linux-2.6.36-orig/fs/Kconfig linux-2.6.36/fs/Kconfig --- linux-2.6.36-orig/fs/Kconfig2010-09-13 01:07:37.0 +0200 +++ linux-2.6.36/fs/Kconfig 2010-09-14 18:49:52.0 +0200 @@ -13,7 +13,7 @@ source fs/ext4/Kconfig config FS_XIP # execute in place bool - depends on EXT2_FS_XIP + depends on EXT2_FS_XIP || PRAMFS_XIP default y source fs/jbd/Kconfig @@ -25,13 +25,14 @@ config FS_MBCACHE default y if EXT2_FS=y EXT2_FS_XATTR default y if EXT3_FS=y EXT3_FS_XATTR default y if EXT4_FS=y EXT4_FS_XATTR - default m if EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4_FS_XATTR + default y if PRAMFS=y PRAMFS_XATTR + default m if EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4_FS_XATTR || PRAMFS_XATTR source fs/reiserfs/Kconfig source fs/jfs/Kconfig config FS_POSIX_ACL -# Posix ACL utility routines (for now, only ext2/ext3/jfs/reiserfs/nfs4) +# Posix ACL utility routines (for now, only ext2/ext3/jfs/reiserfs/nfs4/pramfs) # # NOTE: you can implement Posix ACLs without these helpers (XFS does). # Never use this symbol for ifdefs. @@ -189,6 +190,7 @@ source fs/romfs/Kconfig source fs/sysv/Kconfig source fs/ufs/Kconfig source fs/exofs/Kconfig +source fs/pramfs/Kconfig endif # MISC_FILESYSTEMS diff -Nurp linux-2.6.36-orig/fs/pramfs/Kconfig linux-2.6.36/fs/pramfs/Kconfig --- linux-2.6.36-orig/fs/pramfs/Kconfig 1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/fs/pramfs/Kconfig 2010-12-12 10:42:23.0 +0100 @@ -0,0 +1,72 @@ +config PRAMFS + tristate Persistent and Protected RAM file system support + depends on HAS_IOMEM EXPERIMENTAL + select CRC16 + help + If your system has a block of fast (comparable in access speed to + system memory) and non-volatile RAM and you wish to mount a + light-weight, full-featured, and space-efficient filesystem over it, + say Y here, and read file:Documentation/filesystems/pramfs.txt. + + To compile this as a module, choose M here: the module will be + called pramfs. + +config PRAMFS_XIP + bool Execute-in-place in PRAMFS + depends on PRAMFS + help + Say Y here to enable XIP feature of PRAMFS. + +config PRAMFS_WRITE_PROTECT + bool PRAMFS write protection + depends on PRAMFS MMU HAVE_SET_MEMORY_RO + default y + help + Say Y here to enable the write protect feature of PRAMFS. + +config PRAMFS_XATTR + bool PRAMFS extended attributes + depends on PRAMFS + help + Extended attributes are name:value pairs associated with inodes by + the kernel or by users (see the attr(5) manual page, or visit + http://acl.bestbits.at/ for details). + + If unsure, say N. + +config PRAMFS_POSIX_ACL + bool PRAMFS POSIX Access Control Lists + depends on PRAMFS_XATTR + select FS_POSIX_ACL + help + Posix Access Control Lists (ACLs) support permissions for users and + groups beyond the owner/group/world scheme. + + To learn more about Access Control Lists, visit the Posix ACLs for + Linux website http://acl.bestbits.at/. + + If you don't know what Access Control Lists are, say N. + +config PRAMFS_SECURITY + bool PRAMFS Security Labels + depends on PRAMFS_XATTR + help + Security labels support alternative access control models + implemented by security modules like SELinux. This option + enables an extended attribute handler for file security + labels in the pram filesystem. + + If you are not using a security module that requires using + extended attributes for file security labels, say N. + +config PRAMFS_TEST + boolean + depends on PRAMFS + +config PRAMFS_TEST_MODULE + tristate PRAMFS Test + depends on PRAMFS m + select PRAMFS_TEST + help + Say Y here to build a simple module to test the protection of + PRAMFS. The module will be called pramfs_test. diff -Nurp linux-2.6.36-orig/arch/Kconfig linux-2.6.36/arch/Kconfig --- linux-2.6.36-orig/arch/Kconfig 2010-10-20 22:30:22.0 +0200 +++ linux-2.6.36/arch/Kconfig 2010-11-01 11:42:26.0 +0100 @@ -83,6 +83,9 @@ config USER_RETURN_NOTIFIER config HAVE_IOREMAP_PROT bool +config
[PATCH 14/16 v5] pramfs: memory protection
From: Marco Stornelli marco.storne...@gmail.com
Memory write protection.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/wprotect.c
linux-2.6.36/fs/pramfs/wprotect.c
--- linux-2.6.36-orig/fs/pramfs/wprotect.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/wprotect.c 2010-12-04 11:57:31.0 +0100
@@ -0,0 +1,41 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Write protection for the filesystem pages.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/module.h
+#include linux/fs.h
+#include linux/mm.h
+#include linux/io.h
+#include pram.h
+
+DEFINE_SPINLOCK(writeable_lock);
+
+void pram_writeable(void *vaddr, unsigned long size, int rw)
+{
+ int ret = 0;
+ unsigned long nrpages = size PAGE_SHIFT;
+ unsigned long addr = (unsigned long)vaddr;
+
+ /* Page aligned */
+ addr = PAGE_MASK;
+
+ if (size (PAGE_SIZE - 1))
+ nrpages++;
+
+ if (rw)
+ ret = set_memory_rw(addr, nrpages);
+ else
+ ret = set_memory_ro(addr, nrpages);
+
+ BUG_ON(ret);
+}
diff -Nurp linux-2.6.36-orig/fs/pramfs/wprotect.h
linux-2.6.36/fs/pramfs/wprotect.h
--- linux-2.6.36-orig/fs/pramfs/wprotect.h 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/wprotect.h 2010-12-04 16:45:05.0 +0100
@@ -0,0 +1,149 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Memory protection definitions for the PRAMFS filesystem.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef __WPROTECT_H
+#define __WPROTECT_H
+
+/* pram_memunlock_super() before calling! */
+static inline void pram_sync_super(struct pram_super_block *ps)
+{
+ u16 crc = 0;
+ ps-s_wtime = cpu_to_be32(get_seconds());
+ ps-s_sum = 0;
+ crc = crc16(~0, (__u8 *)ps + sizeof(__be16), PRAM_SB_SIZE -
sizeof(__be16));
+ ps-s_sum = cpu_to_be16(crc);
+ /* Keep sync redundant super block */
+ memcpy((void *)ps + PRAM_SB_SIZE, (void *)ps, PRAM_SB_SIZE);
+}
+
+/* pram_memunlock_inode() before calling! */
+static inline void pram_sync_inode(struct pram_inode *pi)
+{
+ u16 crc = 0;
+ pi-i_sum = 0;
+ crc = crc16(~0, (__u8 *)pi + sizeof(__be16), PRAM_INODE_SIZE -
sizeof(__be16));
+ pi-i_sum = cpu_to_be16(crc);
+}
+
+#ifdef CONFIG_PRAMFS_WRITE_PROTECT
+extern void pram_writeable(void *vaddr, unsigned long size, int rw);
+extern spinlock_t writeable_lock;
+static inline int pram_is_protected(struct super_block *sb)
+{
+ struct pram_sb_info *sbi = (struct pram_sb_info *)sb-s_fs_info;
+ return sbi-s_mount_opt PRAM_MOUNT_PROTECT;
+}
+
+static inline void __pram_memunlock_range(void *p, unsigned long len)
+{
+ /* + * NOTE: Ideally we should lock all the kernel to be memory safe
+* and avoid to write in the protected memory,
+* obviously it's not possible, so we only serialize
+* the operations at fs level. We can't disable the interrupts
+* because we could have a deadlock in this path.
+*/
+ spin_lock(writeable_lock);
+ pram_writeable(p, len, 1);
+}
+
+static inline void __pram_memlock_range(void *p, unsigned long len)
+{
+ pram_writeable(p, len, 0);
+ spin_unlock(writeable_lock);
+}
+
+static inline void pram_memunlock_range(struct super_block *sb, void *p,
+ unsigned long len)
+{
+ if (pram_is_protected(sb))
+ __pram_memunlock_range(p, len);
+}
+
+static inline void pram_memlock_range(struct super_block *sb, void *p,
+ unsigned long len)
+{
+ if (pram_is_protected(sb))
+ __pram_memlock_range(p, len);
+}
+
+static inline void pram_memunlock_super(struct super_block *sb,
+ struct pram_super_block *ps)
+{
+ if (pram_is_protected(sb))
+ __pram_memunlock_range(ps, PRAM_SB_SIZE);
+}
+
+static inline void pram_memlock_super(struct super_block *sb,
+ struct pram_super_block *ps)
+{
+ pram_sync_super(ps);
+ if (pram_is_protected(sb))
+ __pram_memlock_range(ps, PRAM_SB_SIZE);
+}
+
+static inline void pram_memunlock_inode(struct super_block *sb,
+ struct pram_inode *pi)
+{
+ if (pram_is_protected(sb
[PATCH 13/16 v5] pramfs: extended attributes block descriptors tree
From: Marco Stornelli marco.storne...@gmail.com
Extended attributes block descriptors tree.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/desctree.c
linux-2.6.36/fs/pramfs/desctree.c
--- linux-2.6.36-orig/fs/pramfs/desctree.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/desctree.c 2010-11-27 11:12:04.0 +0100
@@ -0,0 +1,181 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Extended attributes block descriptors tree.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/spinlock.h
+#include desctree.h
+#include pram.h
+
+/* xblock_desc_init_always()
+ *
+ * These are initializations that need to be done on every
+ * descriptor allocation as the fields are not initialised
+ * by slab allocation.
+ */
+void xblock_desc_init_always(struct pram_xblock_desc *desc)
+{
+ atomic_set(desc-refcount, 0);
+ desc-blocknr = 0;
+ desc-flags = 0;
+}
+
+/* xblock_desc_init_once()
+ *
+ * These are initializations that only need to be done
+ * once, because the fields are idempotent across use
+ * of the descriptor, so let the slab aware of that.
+ */
+void xblock_desc_init_once(struct pram_xblock_desc *desc)
+{
+ mutex_init(desc-lock);
+}
+
+/* __insert_xblock_desc()
+ *
+ * Insert a new descriptor in the tree.
+ */
+static void __insert_xblock_desc(struct pram_sb_info *sbi,
+unsigned long blocknr, struct rb_node *node)
+{
+ struct rb_node **p = (sbi-desc_tree.rb_node);
+ struct rb_node *parent = NULL;
+ struct pram_xblock_desc *desc;
+
+ while (*p) {
+ parent = *p;
+ desc = rb_entry(parent, struct pram_xblock_desc, node);
+
+ if (blocknr desc-blocknr)
+ p = (*p)-rb_left;
+ else if (blocknr desc-blocknr)
+ p = (*p)-rb_right;
+ else
+ /* Oops...an other descriptor for the same block ? */
+ BUG();
+ }
+
+ rb_link_node(node, parent, p);
+ rb_insert_color(node, sbi-desc_tree);
+}
+
+void insert_xblock_desc(struct pram_sb_info *sbi, struct pram_xblock_desc
*desc)
+{
+ spin_lock(sbi-desc_tree_lock);
+ __insert_xblock_desc(sbi, desc-blocknr, desc-node);
+ spin_unlock(sbi-desc_tree_lock);
+};
+
+/* __lookup_xblock_desc()
+ *
+ * Search an extended attribute descriptor in the tree via the
+ * block number. It returns the descriptor if it's found or
+ * NULL. If not found it creates a new descriptor if create is not 0.
+ */
+static struct pram_xblock_desc *__lookup_xblock_desc(struct pram_sb_info *sbi,
+ unsigned long blocknr,
+ struct kmem_cache *cache,
+ int create)
+{
+ struct rb_node *n = sbi-desc_tree.rb_node;
+ struct pram_xblock_desc *desc = NULL;
+
+ while (n) {
+ desc = rb_entry(n, struct pram_xblock_desc, node);
+
+ if (blocknr desc-blocknr)
+ n = n-rb_left;
+ else if (blocknr desc-blocknr)
+ n = n-rb_right;
+ else {
+ atomic_inc(desc-refcount);
+ goto out;
+ }
+ }
+
+ /* not found */
+ if (create) {
+ desc = kmem_cache_alloc(cache, GFP_NOFS);
+ if (!desc)
+ return ERR_PTR(-ENOMEM);
+ xblock_desc_init_always(desc);
+ atomic_set(desc-refcount, 1);
+ desc-blocknr = blocknr;
+ __insert_xblock_desc(sbi, desc-blocknr, desc-node);
+ }
+out:
+ return desc;
+}
+
+struct pram_xblock_desc *lookup_xblock_desc(struct pram_sb_info *sbi,
+ unsigned long blocknr,
+ struct kmem_cache *cache,
+ int create)
+{
+ struct pram_xblock_desc *desc = NULL;
+
+ spin_lock(sbi-desc_tree_lock);
+ desc = __lookup_xblock_desc(sbi, blocknr, cache, create);
+ spin_unlock(sbi-desc_tree_lock);
+ return desc;
+}
+
+/* put_xblock_desc()
+ *
+ * Decrement the reference count and if it reaches zero and the
+ * desciptor has been marked to be free, then we free it.
+ * It returns 0 if the descriptor has been deleted and 1 otherwise.
+ */
+int put_xblock_desc(struct pram_sb_info *sbi, struct pram_xblock_desc *desc)
+{
+ int ret = 1;
+ if (!desc)
+ return ret;
+
+ if (atomic_dec_and_lock(desc-refcount, sbi-desc_tree_lock)) {
+ if (test_bit(FREEING, desc-flags
[PATCH 06/16 v5] pramfs: inode operations for dirs
From: Marco Stornelli marco.storne...@gmail.com
Inode operations for directories.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/namei.c linux-2.6.36/fs/pramfs/namei.c
--- linux-2.6.36-orig/fs/pramfs/namei.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/namei.c 2010-11-28 10:35:12.0 +0100
@@ -0,0 +1,366 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * Inode operations for directories.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/fs.h
+#include linux/pagemap.h
+#include pram.h
+#include acl.h
+#include xattr.h
+#include xip.h
+
+/*
+ * Couple of helper functions - make the code slightly cleaner.
+ */
+
+static inline void pram_inc_count(struct inode *inode)
+{
+ inode-i_nlink++;
+ pram_write_inode(inode, 0);
+}
+
+static inline void pram_dec_count(struct inode *inode)
+{
+ if (inode-i_nlink) {
+ inode-i_nlink--;
+ pram_write_inode(inode, 0);
+ }
+}
+
+static inline int pram_add_nondir(struct inode *dir,
+ struct dentry *dentry,
+ struct inode *inode)
+{
+ int err = pram_add_link(dentry, inode);
+ if (!err) {
+ d_instantiate(dentry, inode);
+ unlock_new_inode(inode);
+ return 0;
+ }
+ pram_dec_count(inode);
+ unlock_new_inode(inode);
+ iput(inode);
+ return err;
+}
+
+/*
+ * Methods themselves.
+ */
+
+static ino_t
+pram_inode_by_name(struct inode *dir,
+ struct dentry *dentry)
+{
+ struct pram_inode *pi;
+ ino_t ino;
+ int namelen;
+
+ pi = pram_get_inode(dir-i_sb, dir-i_ino);
+ ino = be64_to_cpu(pi-i_type.dir.head);
+
+ while (ino) {
+ pi = pram_get_inode(dir-i_sb, ino);
+
+ if (pi-i_links_count) {
+ namelen = strlen(pi-i_d.d_name);
+
+ if (namelen == dentry-d_name.len
+ !memcmp(dentry-d_name.name,
+ pi-i_d.d_name, namelen))
+ break;
+ }
+
+ ino = be64_to_cpu(pi-i_d.d_next);
+ }
+
+ return ino;
+}
+
+static struct dentry *
+pram_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+{
+ struct inode *inode = NULL;
+ ino_t ino;
+
+ if (dentry-d_name.len PRAM_NAME_LEN)
+ return ERR_PTR(-ENAMETOOLONG);
+
+ ino = pram_inode_by_name(dir, dentry);
+ if (ino) {
+ inode = pram_iget(dir-i_sb, ino);
+ if (!inode)
+ return ERR_PTR(-EACCES);
+ }
+
+ d_splice_alias(inode, dentry);
+ return NULL;
+}
+
+
+/*
+ * By the time this is called, we already have created
+ * the directory cache entry for the new file, but it
+ * is so far negative - it has no inode.
+ *
+ * If the create succeeds, we fill in the inode information
+ * with d_instantiate().
+ */
+static int pram_create(struct inode *dir, struct dentry *dentry,
+ int mode, struct nameidata *nd)
+{
+ struct inode *inode = pram_new_inode(dir, mode);
+ int err = PTR_ERR(inode);
+ if (!IS_ERR(inode)) {
+ inode-i_op = pram_file_inode_operations;
+ if (pram_use_xip(inode-i_sb)) {
+ inode-i_mapping-a_ops = pram_aops_xip;
+ inode-i_fop = pram_xip_file_operations;
+ } else {
+ inode-i_fop = pram_file_operations;
+ inode-i_mapping-a_ops = pram_aops;
+ }
+ err = pram_add_nondir(dir, dentry, inode);
+ }
+ return err;
+}
+
+static int pram_mknod(struct inode *dir, struct dentry *dentry, int mode,
+ dev_t rdev)
+{
+ struct inode *inode = pram_new_inode(dir, mode);
+ int err = PTR_ERR(inode);
+ if (!IS_ERR(inode)) {
+ init_special_inode(inode, mode, rdev);
+ pram_write_inode(inode, 0); /* update rdev */
+ err = pram_add_nondir(dir, dentry, inode);
+ }
+ return err;
+}
+
+static int pram_symlink(struct inode *dir,
+ struct dentry *dentry,
+ const char *symname)
+{
+ struct super_block *sb = dir-i_sb;
+ int err = -ENAMETOOLONG;
+ unsigned len = strlen(symname);
+ struct inode *inode;
+
+ if (len+1 sb-s_blocksize)
+ goto out;
+
+ inode = pram_new_inode
[PATCH 11/16 v5] pramfs: ACL management
From: Marco Stornelli marco.storne...@gmail.com
ACL operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/acl.c linux-2.6.36/fs/pramfs/acl.c
--- linux-2.6.36-orig/fs/pramfs/acl.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/acl.c2010-11-27 14:36:01.0 +0100
@@ -0,0 +1,433 @@
+/*
+ * BRIEF DESCRIPTION
+ *
+ * POSIX ACL operations
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * based on fs/ext2/acl.c with the following copyright:
+ *
+ * Copyright (C) 2001-2003 Andreas Gruenbacher, agr...@suse.de
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/capability.h
+#include linux/init.h
+#include linux/sched.h
+#include linux/slab.h
+#include linux/fs.h
+#include pram.h
+#include xattr.h
+#include acl.h
+
+/*
+ * Load ACL information from filesystem.
+ */
+static struct posix_acl *pram_acl_load(const void *value, size_t size)
+{
+ const char *end = (char *)value + size;
+ int n, count;
+ struct posix_acl *acl;
+
+ if (!value)
+ return NULL;
+ if (size sizeof(struct pram_acl_header))
+return ERR_PTR(-EINVAL);
+ if (((struct pram_acl_header *)value)-a_version !=
+ cpu_to_be32(PRAM_ACL_VERSION))
+ return ERR_PTR(-EINVAL);
+ value = (char *)value + sizeof(struct pram_acl_header);
+ count = pram_acl_count(size);
+ if (count 0)
+ return ERR_PTR(-EINVAL);
+ if (count == 0)
+ return NULL;
+ acl = posix_acl_alloc(count, GFP_KERNEL);
+ if (!acl)
+ return ERR_PTR(-ENOMEM);
+ for (n = 0; n count; n++) {
+ struct pram_acl_entry *entry = (struct pram_acl_entry *)value;
+ if ((char *)value + sizeof(struct pram_acl_entry_short) end)
+ goto fail;
+ acl-a_entries[n].e_tag = be16_to_cpu(entry-e_tag);
+ acl-a_entries[n].e_perm = be16_to_cpu(entry-e_perm);
+ switch (acl-a_entries[n].e_tag) {
+ case ACL_USER_OBJ:
+ case ACL_GROUP_OBJ:
+ case ACL_MASK:
+ case ACL_OTHER:
+ value = (char *)value +
+ sizeof(struct pram_acl_entry_short);
+ acl-a_entries[n].e_id = ACL_UNDEFINED_ID;
+ break;
+ case ACL_USER:
+ case ACL_GROUP:
+ value = (char *)value + sizeof(struct pram_acl_entry);
+ if ((char *)value end)
+ goto fail;
+ acl-a_entries[n].e_id =
+ be32_to_cpu(entry-e_id);
+ break;
+ default:
+ goto fail;
+ }
+ }
+ if (value != end)
+ goto fail;
+ return acl;
+
+fail:
+ posix_acl_release(acl);
+ return ERR_PTR(-EINVAL);
+}
+
+/*
+ * Save ACL information into the filesystem.
+ */
+static void *pram_acl_save(const struct posix_acl *acl, size_t *size)
+{
+ struct pram_acl_header *ext_acl;
+ char *e;
+ size_t n;
+
+ *size = pram_acl_size(acl-a_count);
+ ext_acl = kmalloc(sizeof(struct pram_acl_header) + acl-a_count *
+ sizeof(struct pram_acl_entry), GFP_KERNEL);
+ if (!ext_acl)
+ return ERR_PTR(-ENOMEM);
+ ext_acl-a_version = cpu_to_be32(PRAM_ACL_VERSION);
+ e = (char *)ext_acl + sizeof(struct pram_acl_header);
+ for (n = 0; n acl-a_count; n++) {
+ struct pram_acl_entry *entry = (struct pram_acl_entry *)e;
+ entry-e_tag = cpu_to_be16(acl-a_entries[n].e_tag);
+ entry-e_perm = cpu_to_be16(acl-a_entries[n].e_perm);
+ switch (acl-a_entries[n].e_tag) {
+ case ACL_USER:
+ case ACL_GROUP:
+ entry-e_id =
+ cpu_to_be32(acl-a_entries[n].e_id);
+ e += sizeof(struct pram_acl_entry);
+ break;
+ case ACL_USER_OBJ:
+ case ACL_GROUP_OBJ:
+ case ACL_MASK:
+ case ACL_OTHER:
+ e += sizeof(struct pram_acl_entry_short);
+ break;
+ default:
+ goto fail;
+ }
+ }
+ return (char *)ext_acl;
+
+fail:
+ kfree(ext_acl);
+ return ERR_PTR(-EINVAL);
+}
+
+/*
+ * inode-i_mutex: don't care
+ */
+static struct posix_acl *pram_get_acl(struct inode *inode, int type)
+{
+ int name_index;
+ char *value = NULL;
+ struct posix_acl *acl;
+ int retval
Re: [PATCH 04/16 v4] pramfs: file operations
2010/11/24 Paul Mundt let...@linux-sh.org: On Wed, Nov 24, 2010 at 09:11:13AM +0100, Marco Stornelli wrote: 2010/11/24 Paul Mundt let...@linux-sh.org: most of this from ext2, I'm curious why you opted to hardcode this instead of maintaining the flexibility that ext2 XIP has over this. First of all because it was simpler :) In addition there was some design problem to use it in combination with the memory protection. Do you have more details on this? You can easily check for unsupportable configurations with mount options and bail out accordingly. The difference with ext2 is that we aren't talking about a general purpose fs used (mainly) on normal desktop/server systems, but a specific fs for embedded world, so I think some little constraints are ok. I'm not sure what your point is. It's not a general purpose file system, but that's not an excuse for taking shortcuts. Out of the boards on my desk, I have at least 3 that could make use of this file system where I could use both XIP and non-XIP for different stores out of the box. I wouldn't exactly call it a corner case. Also, as Tony's patch set demonstrates, these sorts of non-volatile data stores are common enough in the server space to make pramfs an option there, too. Please lose this mentality that because something was originally tasked for embedded it's perfectly acceptable to ship a crippled interface. I'm not responsible if someone uses something outside its scope, you can use FAT on a flash but you can't claim reliability. However since I'm a collaborative person I'll try to fix it, implementing where possible a mount option. As it is, this is something that will have to be rewritten one way or the other, but whether that happens in or out of staging/ is not such a big concern. Good. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 04/16 v4] pramfs: file operations
2010/11/24 Paul Mundt let...@linux-sh.org:
On Sat, Nov 20, 2010 at 10:58:40AM +0100, Marco Stornelli wrote:
diff -Nurp linux-2.6.36-orig/fs/pramfs/file.c linux-2.6.36/fs/pramfs/file.c
--- linux-2.6.36-orig/fs/pramfs/file.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/file.c 2010-09-24 18:34:03.0 +0200
@@ -0,0 +1,166 @@
+/*
+ * FILE NAME fs/pramfs/file.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * File operations for files.
+ *
This FILE NAME / BRIEF DESCRIPTION thing should probably die, it's also
not used consistently throughout the series.
Maybe yes, it's more a problem then a advantage :)
+static int pram_open_file(struct inode *inode, struct file *filp)
+{
+#ifndef CONFIG_PRAMFS_XIP
+ /* Without XIP we force to use Direct IO */
+ filp-f_flags |= O_DIRECT;
+#endif
+ return generic_file_open(inode, filp);
+}
+
Relying on a config option for this is in violently poor taste. Rely on
the config option to enable/disable XIP support as you like, but whether
it's actually mounted XIP or not should really depend be determined by a
mount option. Presently you have no way of dealing with the file system
being mounted multiple times with mixed XIP and non-XIP, which doesn't
seem like a particularly exotic configuration. As you seem to have copied
Maybe on embedded, it could be.
most of this from ext2, I'm curious why you opted to hardcode this
instead of maintaining the flexibility that ext2 XIP has over this.
First of all because it was simpler :) In addition there was some
design problem to use it in combination with the memory protection.
The difference with ext2 is that we aren't talking about a general
purpose fs used (mainly) on normal desktop/server systems, but a
specific fs for embedded world, so I think some little constraints are
ok.
Marco
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 01/16 v4] pramfs: documentation
From: Marco Stornelli marco.storne...@gmail.com Documentation for PRAMFS. Signed-off-by: Marco Stornelli marco.storne...@gmail.com --- diff -Nurp linux-2.6.36-orig/Documentation/filesystems/pramfs.txt linux-2.6.36/Documentation/filesystems/pramfs.txt --- linux-2.6.36-orig/Documentation/filesystems/pramfs.txt 1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/Documentation/filesystems/pramfs.txt 2010-10-23 09:04:32.0 +0200 @@ -0,0 +1,296 @@ + +PRAMFS Overview +=== + +Many embedded systems have a block of non-volatile RAM separate from +normal system memory, i.e. of which the kernel maintains no memory page +descriptors. For such systems it would be beneficial to mount a +fast read/write filesystem over this I/O memory, for storing frequently +accessed data that must survive system reboots and power cycles. An +example usage might be system logs under /var/log, or a user address +book in a cell phone or PDA. + +Linux traditionally had no support for a persistent, non-volatile RAM-based +filesystem, persistent meaning the filesystem survives a system reboot +or power cycle intact. The RAM-based filesystems such as tmpfs and ramfs +have no actual backing store but exist entirely in the page and buffer +caches, hence the filesystem disappears after a system reboot or +power cycle. + +A relatively straightforward solution is to write a simple block driver +for the non-volatile RAM, and mount over it any disk-based filesystem such +as ext2, ext3, ext4, etc. + +But the disk-based fs over non-volatile RAM block driver approach has +some drawbacks: + +1. Complexity of disk-based fs: disk-based filesystems such as ext2/ext3/ext4 + were designed for optimum performance on spinning disk media, so they + implement features such as block groups, which attempts to group inode data + into a contiguous set of data blocks to minimize disk seeking when accessing + files. For RAM there is no such concern; a file's data blocks can be + scattered throughout the media with no access speed penalty at all. So block + groups in a filesystem mounted over RAM just adds unnecessary + complexity. A better approach is to use a filesystem specifically + tailored to RAM media which does away with these disk-based features. + This increases the efficient use of space on the media, i.e. more + space is dedicated to actual file data storage and less to meta-data + needed to maintain that file data. + +2. Different problems between disks and RAM: Because PRAMFS attempts to avoid + filesystem corruption caused by kernel bugs, dirty pages in the page cache + are not allowed to be written back to the backing-store RAM. This way, an + errant write into the page cache will not get written back to the filesystem. + However, if the backing-store RAM is comparable in access speed to system + memory, the penalty of not using caching is minimal. With this consideration + it's better to move file data directly between the user buffers and the backing + store RAM, i.e. use direct I/O. This prevents the unnecessary populating of + the page cache with dirty pages. However direct I/O has to be enabled at + every file open. To enable direct I/O at all times for all regular files + requires either that applications be modified to include the O_DIRECT flag on + all file opens, or that the filesystem used performs direct I/O by default. + +The Persistent/Protected RAM Special Filesystem (PRAMFS) is a read/write +filesystem that has been designed to address these issues. PRAMFS is targeted +to fast I/O memory, and if the memory is non-volatile, the filesystem will be +persistent. + +In PRAMFS, direct I/O is enabled across all files in the filesystem, in other +words the O_DIRECT flag is forced on every open of a PRAMFS file. Also, file +I/O in the PRAMFS is always synchronous. There is no need to block the current +process while the transfer to/from the PRAMFS is in progress, since one of +the requirements of the PRAMFS is that the filesystem exists in fast RAM. So +file I/O in PRAMFS is always direct, synchronous, and never blocks. + +The data organization in PRAMFS can be thought of as an extremely simplified +version of ext2, such that the ratio of data to meta-data is very high. + +PRAMFS supports the execute-in-place. With XIP, instead of keeping data in the +page cache, the need to have a page cache copy is eliminated completely. +Readwrite type operations are performed directly from/to the memory. For file +mappings, the RAM itself is mapped directly into userspace. XIP, in addition, +speed up the applications start-up time because it removes the needs of any +copies. + +PRAMFS is write protected. The page table entries that map the backing-store +RAM are normally marked read-only. Write operations into the filesystem +temporarily mark the affected pages as writeable, the write operation is +carried out with locks held, and then the page table entries is +marked read-only
[PATCH 03/26 v4] pramfs: inode operations
From: Marco Stornelli marco.storne...@gmail.com
Inode methods (allocate/free/read/write).
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/inode.c linux-2.6.36/fs/pramfs/inode.c
--- linux-2.6.36-orig/fs/pramfs/inode.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/inode.c 2010-09-26 18:04:38.0 +0200
@@ -0,0 +1,710 @@
+/*
+ * FILE NAME fs/pramfs/inode.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Inode methods (allocate/free/read/write).
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/smp_lock.h
+#include linux/sched.h
+#include linux/highuid.h
+#include linux/quotaops.h
+#include linux/module.h
+#include linux/mpage.h
+#include linux/backing-dev.h
+#include pram.h
+#include xattr.h
+#include xip.h
+#include acl.h
+
+struct backing_dev_info pram_backing_dev_info __read_mostly = {
+ .ra_pages = 0,/* No readahead */
+ .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK,
+};
+
+/*
+ * allocate a data block for inode and return it's absolute blocknr.
+ * Zeroes out the block if zero set. Increments inode-i_blocks.
+ */
+static int pram_new_data_block(struct inode *inode, unsigned long *blocknr,
int zero)
+{
+ int errval = pram_new_block(inode-i_sb, blocknr, zero);
+
+ if (!errval) {
+ struct pram_inode *pi = pram_get_inode(inode-i_sb,
+ inode-i_ino);
+ inode-i_blocks++;
+ pram_memunlock_inode(pi);
+ pi-i_blocks = cpu_to_be32(inode-i_blocks);
+ pram_memlock_inode(pi);
+ }
+
+ return errval;
+}
+
+/*
+ * find the offset to the block represented by the given inode's file
+ * relative block number.
+ */
+u64 pram_find_data_block(struct inode *inode, int file_blocknr)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *pi;
+ u64 *row; /* ptr to row block */
+ u64 *col; /* ptr to column blocks */
+ u64 bp = 0;
+ int i_row, i_col;
+ int N = sb-s_blocksize 3; /* num block ptrs per block */
+ int Nbits = sb-s_blocksize_bits - 3;
+
+ pi = pram_get_inode(sb, inode-i_ino);
+
+ i_row = file_blocknr Nbits;
+ i_col = file_blocknr (N-1);
+
+ row = pram_get_block(sb, be64_to_cpu(pi-i_type.reg.row_block));
+ if (row) {
+ col = pram_get_block(sb, be64_to_cpu(row[i_row]));
+ if (col)
+ bp = be64_to_cpu(col[i_col]);
+ }
+
+ return bp;
+}
+
+/*
+ * Free data blocks from inode in the range start = end
+ */
+static void __pram_truncate_blocks(struct inode *inode, loff_t start, loff_t
end)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *pi = pram_get_inode(sb, inode-i_ino);
+ int N = sb-s_blocksize 3; /* num block ptrs per block */
+ int Nbits = sb-s_blocksize_bits - 3;
+ int first_row_index, last_row_index, i, j;
+ unsigned long blocknr, first_blocknr, last_blocknr;
+ unsigned int freed = 0;
+ u64 *row; /* ptr to row block */
+ u64 *col; /* ptr to column blocks */
+
+ if (start end || !inode-i_blocks || !pi-i_type.reg.row_block)
+ return;
+
+ mutex_lock(PRAM_I(inode)-truncate_mutex);
+
+ first_blocknr = (start + sb-s_blocksize - 1) sb-s_blocksize_bits;
+ last_blocknr = (end + sb-s_blocksize - 1) sb-s_blocksize_bits;
+ first_row_index = first_blocknr Nbits;
+ last_row_index = last_blocknr Nbits;
+
+ row = pram_get_block(sb, be64_to_cpu(pi-i_type.reg.row_block));
+
+ for (i = first_row_index; i = last_row_index; i++) {
+ int first_col_index = (i == first_row_index) ?
+ first_blocknr (N-1) : 0;
+ int last_col_index = (i == last_row_index) ?
+ last_blocknr (N-1) : N-1;
+
+ if (unlikely(!row[i]))
+ continue;
+
+ col = pram_get_block(sb, be64_to_cpu(row[i]));
+
+ for (j = first_col_index; j = last_col_index; j++) {
+
+ if (unlikely(!col[j]))
+ continue;
+
+ blocknr = pram_get_blocknr(sb, be64_to_cpu(col[j]));
+ pram_free_block(sb, blocknr);
+ freed++;
+ pram_memunlock_block(sb, col);
+ col[j] = 0;
+ pram_memlock_block(sb, col);
+ }
+
+ if (first_col_index == 0
[PATCH 04/16 v4] pramfs: file operations
From: Marco Stornelli marco.storne...@gmail.com
File operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/file.c linux-2.6.36/fs/pramfs/file.c
--- linux-2.6.36-orig/fs/pramfs/file.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/file.c 2010-09-24 18:34:03.0 +0200
@@ -0,0 +1,166 @@
+/*
+ * FILE NAME fs/pramfs/file.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * File operations for files.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/fs.h
+#include linux/sched.h
+#include linux/slab.h
+#include linux/uio.h
+#include linux/mm.h
+#include linux/uaccess.h
+#include pram.h
+#include acl.h
+#include xip.h
+#include xattr.h
+
+static int pram_open_file(struct inode *inode, struct file *filp)
+{
+#ifndef CONFIG_PRAMFS_XIP
+ /* Without XIP we force to use Direct IO */
+ filp-f_flags |= O_DIRECT;
+#endif
+ return generic_file_open(inode, filp);
+}
+
+ssize_t __pram_direct_IO(int rw, struct kiocb *iocb,
+ const struct iovec *iov,
+ loff_t offset, unsigned long nr_segs)
+{
+ struct file *file = iocb-ki_filp;
+ struct inode *inode = file-f_mapping-host;
+ struct super_block *sb = inode-i_sb;
+ int progress = 0, hole = 0;
+ ssize_t retval = 0;
+ void *tmp = NULL;
+ unsigned long blocknr, blockoff;
+ int num_blocks, blocksize_mask, blocksize, blocksize_bits;
+ char __user *buf = iov-iov_base;
+ size_t length = iov_length(iov, nr_segs);
+
+ if (length 0)
+ return -EINVAL;
+ if ((rw == READ) (offset + length inode-i_size))
+ length = inode-i_size - offset;
+ if (!length)
+ goto out;
+
+ blocksize_bits = inode-i_sb-s_blocksize_bits;
+ blocksize = 1 blocksize_bits;
+ blocksize_mask = blocksize - 1;
+
+ /* find starting block number to access */
+ blocknr = offset blocksize_bits;
+ /* find starting offset within starting block */
+ blockoff = offset blocksize_mask;
+ /* find number of blocks to access */
+ num_blocks = (blockoff + length + blocksize_mask) blocksize_bits;
+
+ if (rw == WRITE) {
+ /* prepare a temporary buffer to hold a user data block
+ for writing. */
+ tmp = kmalloc(blocksize, GFP_KERNEL);
+ if (!tmp)
+ return -ENOMEM;
+ /* now allocate the data blocks we'll need */
+ retval = pram_alloc_blocks(inode, blocknr, num_blocks);
+ if (retval)
+ goto fail1;
+ }
+
+ while (length) {
+ int count;
+ u8 *bp = NULL;
+ u64 block = pram_find_data_block(inode, blocknr++);
+ if (unlikely(!block rw == READ)) {
+ /* We are falling in a hole */
+ hole = 1;
+ } else {
+ bp = (u8 *)pram_get_block(sb, block);
+ if (!bp)
+ goto fail2;
+ }
+
+ count = blockoff + length blocksize ?
+ blocksize - blockoff : length;
+
+ if (rw == READ) {
+ if (unlikely(hole)) {
+ retval = clear_user(buf, count);
+ if (retval) {
+ retval = -EFAULT;
+ goto fail1;
+ }
+ } else {
+ retval = copy_to_user(buf, bp[blockoff],
count);
+ if (retval) {
+ retval = -EFAULT;
+ goto fail1;
+ }
+ }
+ } else {
+ retval = copy_from_user(tmp, buf, count);
+ if (retval) {
+ retval = -EFAULT;
+ goto fail1;
+ }
+
+ pram_memunlock_block(inode-i_sb, bp);
+ memcpy(bp[blockoff], tmp, count);
+ pram_memlock_block(inode-i_sb, bp);
+ }
+
+ progress += count;
+ buf += count;
+ length -= count;
+ blockoff = 0;
+ hole = 0;
+ }
+
+fail2:
+ retval = progress;
+fail1:
+ kfree(tmp);
+out
[PATCH 05/16 v4] pramfs: block allocation
From: Marco Stornelli marco.storne...@gmail.com
Block allocation operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/balloc.c linux-2.6.36/fs/pramfs/balloc.c
--- linux-2.6.36-orig/fs/pramfs/balloc.c1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/balloc.c 2010-09-26 18:05:06.0 +0200
@@ -0,0 +1,149 @@
+/*
+ * FILE NAME fs/pramfs/balloc.c
+ *
+ * BRIEF MODULE DESCRIPTION
+ *
+ * The blocks allocation and deallocation routines.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/bitops.h
+#include pram.h
+
+/*
+ * This just marks in-use the blocks that make up the bitmap.
+ * The bitmap must be writeable before calling.
+ */
+void pram_init_bitmap(struct super_block *sb)
+{
+ struct pram_super_block *ps = pram_get_super(sb);
+ unsigned long *bitmap = pram_get_bitmap(sb);
+ int blocks = be32_to_cpu(ps-s_bitmap_blocks);
+
+ memset(bitmap, 0, blocks sb-s_blocksize_bits);
+
+ bitmap_set(bitmap, 0, blocks);
+}
+
+
+/* Free absolute blocknr */
+void pram_free_block(struct super_block *sb, unsigned long blocknr)
+{
+ struct pram_super_block *ps;
+ u64 bitmap_block;
+ unsigned long bitmap_bnr;
+ void *bitmap;
+ void *bp;
+
+ lock_super(sb);
+
+ bitmap = pram_get_bitmap(sb);
+ /*
+* find the block within the bitmap that contains the inuse bit
+* for the block we need to free. We need to unlock this bitmap
+* block to clear the inuse bit.
+*/
+ bitmap_bnr = blocknr (3 + sb-s_blocksize_bits);
+ bitmap_block = pram_get_block_off(sb, bitmap_bnr);
+ bp = pram_get_block(sb, bitmap_block);
+
+ pram_memunlock_block(sb, bp);
+ pram_clear_bit(blocknr, bitmap); /* mark the block free */
+ pram_memlock_block(sb, bp);
+
+ ps = pram_get_super(sb);
+ pram_memunlock_super(ps);
+ if (blocknr be32_to_cpu(ps-s_free_blocknr_hint))
+ ps-s_free_blocknr_hint = cpu_to_be32(blocknr);
+ be32_add_cpu(ps-s_free_blocks_count, 1);
+ pram_memlock_super(ps);
+
+ unlock_super(sb);
+}
+
+
+/*
+ * allocate a block and return it's absolute blocknr. Zeroes out the
+ * block if zero set.
+ */
+int pram_new_block(struct super_block *sb, unsigned long *blocknr, int zero)
+{
+ struct pram_super_block *ps;
+ u64 bitmap_block;
+ unsigned long bnr, bitmap_bnr;
+ int errval;
+ void *bitmap;
+ void *bp;
+
+ lock_super(sb);
+ ps = pram_get_super(sb);
+ bitmap = pram_get_bitmap(sb);
+
+ if (ps-s_free_blocks_count) {
+ /* find the oldest unused block */
+ bnr = pram_find_next_zero_bit(bitmap,
+be32_to_cpu(ps-s_blocks_count),
+be32_to_cpu(ps-s_free_blocknr_hint));
+
+ if (bnr be32_to_cpu(ps-s_bitmap_blocks) ||
+ bnr = be32_to_cpu(ps-s_blocks_count)) {
+ pram_err(no free blocks found!\n);
+ errval = -ENOSPC;
+ goto fail;
+ }
+
+ pram_dbg(allocating blocknr %lu\n, bnr);
+ pram_memunlock_super(ps);
+ be32_add_cpu(ps-s_free_blocks_count, -1);
+ if (bnr (be32_to_cpu(ps-s_blocks_count)-1))
+ ps-s_free_blocknr_hint = cpu_to_be32(bnr+1);
+ else
+ ps-s_free_blocknr_hint = 0;
+ pram_memlock_super(ps);
+ } else {
+ pram_err(all blocks allocated\n);
+ errval = -ENOSPC;
+ goto fail;
+ }
+
+ /*
+* find the block within the bitmap that contains the inuse bit
+* for the unused block we just found. We need to unlock it to
+* set the inuse bit.
+*/
+ bitmap_bnr = bnr (3 + sb-s_blocksize_bits);
+ bitmap_block = pram_get_block_off(sb, bitmap_bnr);
+ bp = pram_get_block(sb, bitmap_block);
+
+ pram_memunlock_block(sb, bp);
+ pram_set_bit(bnr, bitmap); /* mark the new block in use */
+ pram_memlock_block(sb, bp);
+
+ if (zero) {
+ bp = pram_get_block(sb, pram_get_block_off(sb, bnr));
+ pram_memunlock_block(sb, bp);
+ memset(bp, 0, sb-s_blocksize);
+ pram_memlock_block(sb, bp);
+ }
+
+ *blocknr = bnr;
+ pram_dbg(allocated blocknr %lu, bnr);
+ errval = 0;
+ fail
[PATCH 06/16 v4] pramfs: Inode operations for directories
From: Marco Stornelli marco.storne...@gmail.com
Inode operations for directories.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/namei.c linux-2.6.36/fs/pramfs/namei.c
--- linux-2.6.36-orig/fs/pramfs/namei.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/namei.c 2010-09-18 12:00:35.0 +0200
@@ -0,0 +1,363 @@
+/*
+ * FILE NAME fs/pramfs/namei.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Inode operations for directories.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/fs.h
+#include linux/pagemap.h
+#include pram.h
+#include acl.h
+#include xattr.h
+
+/*
+ * Couple of helper functions - make the code slightly cleaner.
+ */
+
+static inline void pram_inc_count(struct inode *inode)
+{
+ inode-i_nlink++;
+ pram_write_inode(inode, 0);
+}
+
+static inline void pram_dec_count(struct inode *inode)
+{
+ if (inode-i_nlink) {
+ inode-i_nlink--;
+ pram_write_inode(inode, 0);
+ }
+}
+
+static inline int pram_add_nondir(struct inode *dir,
+ struct dentry *dentry,
+ struct inode *inode)
+{
+ int err = pram_add_link(dentry, inode);
+ if (!err) {
+ d_instantiate(dentry, inode);
+ unlock_new_inode(inode);
+ return 0;
+ }
+ pram_dec_count(inode);
+ unlock_new_inode(inode);
+ iput(inode);
+ return err;
+}
+
+/*
+ * Methods themselves.
+ */
+
+static ino_t
+pram_inode_by_name(struct inode *dir,
+ struct dentry *dentry)
+{
+ struct pram_inode *pi;
+ ino_t ino;
+ int namelen;
+
+ pi = pram_get_inode(dir-i_sb, dir-i_ino);
+ ino = be64_to_cpu(pi-i_type.dir.head);
+
+ while (ino) {
+ pi = pram_get_inode(dir-i_sb, ino);
+
+ if (pi-i_links_count) {
+ namelen = strlen(pi-i_d.d_name);
+
+ if (namelen == dentry-d_name.len
+ !memcmp(dentry-d_name.name,
+ pi-i_d.d_name, namelen))
+ break;
+ }
+
+ ino = be64_to_cpu(pi-i_d.d_next);
+ }
+
+ return ino;
+}
+
+static struct dentry *
+pram_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+{
+ struct inode *inode = NULL;
+ ino_t ino;
+
+ if (dentry-d_name.len PRAM_NAME_LEN)
+ return ERR_PTR(-ENAMETOOLONG);
+
+ ino = pram_inode_by_name(dir, dentry);
+ if (ino) {
+ inode = pram_iget(dir-i_sb, ino);
+ if (!inode)
+ return ERR_PTR(-EACCES);
+ }
+
+ d_splice_alias(inode, dentry);
+ return NULL;
+}
+
+
+/*
+ * By the time this is called, we already have created
+ * the directory cache entry for the new file, but it
+ * is so far negative - it has no inode.
+ *
+ * If the create succeeds, we fill in the inode information
+ * with d_instantiate().
+ */
+static int pram_create(struct inode *dir, struct dentry *dentry,
+ int mode, struct nameidata *nd)
+{
+ struct inode *inode = pram_new_inode(dir, mode);
+ int err = PTR_ERR(inode);
+ if (!IS_ERR(inode)) {
+
+ inode-i_op = pram_file_inode_operations;
+ inode-i_fop = pram_file_operations;
+ inode-i_mapping-a_ops = pram_aops;
+ err = pram_add_nondir(dir, dentry, inode);
+ }
+ return err;
+}
+
+static int pram_mknod(struct inode *dir, struct dentry *dentry, int mode,
+ dev_t rdev)
+{
+ struct inode *inode = pram_new_inode(dir, mode);
+ int err = PTR_ERR(inode);
+ if (!IS_ERR(inode)) {
+ init_special_inode(inode, mode, rdev);
+ pram_write_inode(inode, 0); /* update rdev */
+ err = pram_add_nondir(dir, dentry, inode);
+ }
+ return err;
+}
+
+static int pram_symlink(struct inode *dir,
+ struct dentry *dentry,
+ const char *symname)
+{
+ struct super_block *sb = dir-i_sb;
+ int err = -ENAMETOOLONG;
+ unsigned len = strlen(symname);
+ struct inode *inode;
+
+ if (len+1 sb-s_blocksize)
+ goto out;
+
+ inode = pram_new_inode(dir, S_IFLNK | S_IRWXUGO);
+ err = PTR_ERR(inode);
+ if (IS_ERR(inode))
+ goto out;
+
+ inode-i_op = pram_symlink_inode_operations;
+ inode-i_mapping-a_ops = pram_aops
[PATCH 07/16 v4] pramfs: symbolic links
From: Marco Stornelli marco.storne...@gmail.com
Symlink operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/symlink.c
linux-2.6.36/fs/pramfs/symlink.c
--- linux-2.6.36-orig/fs/pramfs/symlink.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/symlink.c2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,78 @@
+/*
+ * FILE NAME fs/pramfs/symlink.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Symlink operations
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include pram.h
+#include xattr.h
+
+int pram_block_symlink(struct inode *inode, const char *symname, int len)
+{
+ struct super_block *sb = inode-i_sb;
+ u64 block;
+ char *blockp;
+ int err;
+
+ err = pram_alloc_blocks(inode, 0, 1);
+ if (err)
+ return err;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+
+ pram_memunlock_block(sb, blockp);
+ memcpy(blockp, symname, len);
+ blockp[len] = '\0';
+ pram_memlock_block(sb, blockp);
+ return 0;
+}
+
+static int pram_readlink(struct dentry *dentry, char *buffer, int buflen)
+{
+ struct inode *inode = dentry-d_inode;
+ struct super_block *sb = inode-i_sb;
+ u64 block;
+ char *blockp;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+ return vfs_readlink(dentry, buffer, buflen, blockp);
+}
+
+static void *pram_follow_link(struct dentry *dentry, struct nameidata *nd)
+{
+ struct inode *inode = dentry-d_inode;
+ struct super_block *sb = inode-i_sb;
+ off_t block;
+ int status;
+ char *blockp;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+ status = vfs_follow_link(nd, blockp);
+ return ERR_PTR(status);
+}
+
+struct inode_operations pram_symlink_inode_operations = {
+ .readlink = pram_readlink,
+ .follow_link= pram_follow_link,
+ .setattr= pram_notify_change,
+#ifdef CONFIG_PRAMFS_XATTR
+ .setxattr = generic_setxattr,
+ .getxattr = generic_getxattr,
+ .listxattr = pram_listxattr,
+ .removexattr= generic_removexattr,
+#endif
+};
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 08/16 v4] pramfs: headers
From: Marco Stornelli marco.storne...@gmail.com
Definitions for the PRAMFS filesystem.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/pram.h linux-2.6.36/fs/pramfs/pram.h
--- linux-2.6.36-orig/fs/pramfs/pram.h 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/pram.h 2010-10-30 12:02:45.0 +0200
@@ -0,0 +1,317 @@
+/*
+ * FILE NAME pram.h
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Definitions for the PRAMFS filesystem.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#ifndef __PRAM_H
+#define __PRAM_H
+
+#include linux/buffer_head.h
+#include linux/pram_fs.h
+#include linux/pram_fs_sb.h
+#include linux/crc16.h
+#include linux/mutex.h
+#include linux/types.h
+
+/*
+ * Debug code
+ */
+#define pram_dbg(s, args...) pr_debug(PRAMFS: s, ## args)
+#define pram_err(s, args...) pr_err(PRAMFS: s, ## args)
+#define pram_warn(s, args...) pr_warning(PRAMFS: s, ## args)
+#define pram_info(s, args...) pr_info(PRAMFS: s, ## args)
+
+/* Function Prototypes */
+
+#ifdef CONFIG_PRAMFS_XIP
+
+#define pram_read xip_file_read
+#define pram_write xip_file_write
+#define pram_mmap xip_file_mmap
+#define pram_aio_read NULL
+#define pram_aio_write NULL
+#define pram_readpage NULL
+#define pram_direct_IO NULL
+
+#else
+
+#define pram_read do_sync_read
+#define pram_write do_sync_write
+#define pram_mmap __pram_mmap
+#define pram_aio_read generic_file_aio_read
+#define pram_aio_write generic_file_aio_write
+#define pram_direct_IO __pram_direct_IO
+#define pram_readpage __pram_readpage
+
+extern int pram_get_and_update_block(struct inode *inode, sector_t iblock,
+struct buffer_head *bh, int create);
+
+static inline int __pram_readpage(struct file *file, struct page *page)
+{
+ return block_read_full_page(page, pram_get_and_update_block);
+}
+
+/* file.c */
+extern ssize_t __pram_direct_IO(int rw, struct kiocb *iocb,
+ const struct iovec *iov,
+ loff_t offset, unsigned long nr_segs);
+extern int __pram_mmap(struct file *file, struct vm_area_struct *vma);
+
+#endif /* CONFIG_PRAMFS_XIP */
+
+#define pram_set_bit ext2_set_bit
+#define pram_clear_bit ext2_clear_bit
+#define pram_find_next_zero_bitext2_find_next_zero_bit
+
+/* balloc.c */
+extern void pram_init_bitmap(struct super_block *sb);
+extern void pram_free_block(struct super_block *sb, unsigned long blocknr);
+extern int pram_new_block(struct super_block *sb, unsigned long *blocknr, int
zero);
+extern unsigned long pram_count_free_blocks(struct super_block *sb);
+
+/* dir.c */
+extern int pram_add_link(struct dentry *dentry, struct inode *inode);
+extern int pram_remove_link(struct inode *inode);
+
+/* namei.c */
+extern struct dentry *pram_get_parent(struct dentry *child);
+
+/* inode.c */
+extern int pram_alloc_blocks(struct inode *inode, int file_blocknr, int num);
+extern u64 pram_find_data_block(struct inode *inode,
+int file_blocknr);
+
+extern struct inode *pram_iget(struct super_block *sb, unsigned long ino);
+extern void pram_put_inode(struct inode *inode);
+extern void pram_evict_inode(struct inode *inode);
+extern struct inode *pram_new_inode(struct inode *dir, int mode);
+extern int pram_update_inode(struct inode *inode);
+extern int pram_write_inode(struct inode *inode, struct writeback_control
*wbc);
+extern void pram_dirty_inode(struct inode *inode);
+extern int pram_notify_change(struct dentry *dentry, struct iattr *attr);
+
+
+/* super.c */
+#ifdef CONFIG_PRAMFS_TEST
+extern struct pram_super_block *get_pram_super(void);
+#endif
+extern struct super_block *pram_read_super(struct super_block *sb,
+ void *data,
+ int silent);
+extern int pram_statfs(struct dentry *d, struct kstatfs *buf);
+extern int pram_remount(struct super_block *sb, int *flags, char *data);
+
+/* symlink.c */
+extern int pram_block_symlink(struct inode *inode,
+ const char *symname, int len);
+
+
+#ifdef CONFIG_PRAMFS_WRITE_PROTECT
+extern void pram_writeable(void *vaddr, unsigned long size, int rw);
+
+#define wrprotect(addr, size) pram_writeable(addr, size, 0)
+
+#else
+
+#define wrprotect(addr, size) do {} while (0)
+
+#endif /* CONFIG PRAMFS_WRITE_PROTECT */
+
+/* Inline functions start here */
+
+static inline int pram_calc_checksum(u8 *data, int n)
+{
+ u16 crc = 0;
+ crc = crc16(~0, (__u8 *)data + sizeof
[PATCH 09/16 v4] pramfs: dir operations
From: Marco Stornelli marco.storne...@gmail.com
File operations for directories.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/dir.c linux-2.6.36/fs/pramfs/dir.c
--- linux-2.6.36-orig/fs/pramfs/dir.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/dir.c2010-09-17 19:08:54.0 +0200
@@ -0,0 +1,215 @@
+/*
+ * FILE NAME fs/pramfs/dir.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * File operations for directories.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/pagemap.h
+#include pram.h
+
+/*
+ * Parent is locked.
+ */
+int pram_add_link(struct dentry *dentry, struct inode *inode)
+{
+ struct inode *dir = dentry-d_parent-d_inode;
+ struct pram_inode *pidir, *pi, *pitail = NULL;
+ u64 tail_ino, prev_ino;
+
+ const char *name = dentry-d_name.name;
+
+ int namelen = dentry-d_name.len PRAM_NAME_LEN ?
+ PRAM_NAME_LEN : dentry-d_name.len;
+
+ pidir = pram_get_inode(dir-i_sb, dir-i_ino);
+ pi = pram_get_inode(dir-i_sb, inode-i_ino);
+
+ dir-i_mtime = dir-i_ctime = CURRENT_TIME;
+
+ tail_ino = be64_to_cpu(pidir-i_type.dir.tail);
+ if (tail_ino != 0) {
+ pitail = pram_get_inode(dir-i_sb, tail_ino);
+ pram_memunlock_inode(pitail);
+ pitail-i_d.d_next = cpu_to_be64(inode-i_ino);
+ pram_memlock_inode(pitail);
+
+ prev_ino = tail_ino;
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = cpu_to_be64(inode-i_ino);
+ pidir-i_mtime = cpu_to_be32(dir-i_mtime.tv_sec);
+ pidir-i_ctime = cpu_to_be32(dir-i_ctime.tv_sec);
+ pram_memlock_inode(pidir);
+ } else {
+ /* the directory is empty */
+ prev_ino = 0;
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = cpu_to_be64(inode-i_ino);
+ pidir-i_type.dir.head = cpu_to_be64(inode-i_ino);
+ pidir-i_mtime = cpu_to_be32(dir-i_mtime.tv_sec);
+ pidir-i_ctime = cpu_to_be32(dir-i_ctime.tv_sec);
+ pram_memlock_inode(pidir);
+ }
+
+
+ pram_memunlock_inode(pi);
+ pi-i_d.d_prev = cpu_to_be64(prev_ino);
+ pi-i_d.d_parent = cpu_to_be64(dir-i_ino);
+ memcpy(pi-i_d.d_name, name, namelen);
+ pi-i_d.d_name[namelen] = '\0';
+ pram_memlock_inode(pi);
+ return 0;
+}
+
+int pram_remove_link(struct inode *inode)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *prev = NULL;
+ struct pram_inode *next = NULL;
+ struct pram_inode *pidir, *pi;
+
+ pi = pram_get_inode(sb, inode-i_ino);
+ pidir = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_parent));
+ if (!pidir)
+ return -EACCES;
+
+ if (inode-i_ino == be64_to_cpu(pidir-i_type.dir.head)) {
+ /* first inode in directory */
+ next = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_next));
+
+ if (next) {
+ pram_memunlock_inode(next);
+ next-i_d.d_prev = 0;
+ pram_memlock_inode(next);
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.head = pi-i_d.d_next;
+ } else {
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.head = 0;
+ pidir-i_type.dir.tail = 0;
+ }
+ pram_memlock_inode(pidir);
+ } else if (inode-i_ino == be64_to_cpu(pidir-i_type.dir.tail)) {
+ /* last inode in directory */
+ prev = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_prev));
+
+ pram_memunlock_inode(prev);
+ prev-i_d.d_next = 0;
+ pram_memlock_inode(prev);
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = pi-i_d.d_prev;
+ pram_memlock_inode(pidir);
+ } else {
+ /* somewhere in the middle */
+ prev = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_prev));
+ next = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_next));
+
+ if (prev next) {
+ pram_memunlock_inode(prev);
+ prev-i_d.d_next = pi-i_d.d_next;
+ pram_memlock_inode(prev);
+
+ pram_memunlock_inode(next);
+ next-i_d.d_prev = pi-i_d.d_prev
[PATCH 10/16 v4] pramfs: xip operations
From: Marco Stornelli marco.storne...@gmail.com
XIP operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/xip.c linux-2.6.36/fs/pramfs/xip.c
--- linux-2.6.36-orig/fs/pramfs/xip.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/xip.c2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,90 @@
+/*
+ * FILE NAME fs/pramfs/xip.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * XIP operations.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/mm.h
+#include linux/fs.h
+#include linux/genhd.h
+#include linux/buffer_head.h
+#include pram.h
+#include xip.h
+
+static int pram_find_and_alloc_blocks(struct inode *inode, sector_t iblock,
+sector_t *data_block, int create)
+{
+ int err = -EIO;
+ u64 block;
+
+ mutex_lock(PRAM_I(inode)-truncate_mutex);
+
+ block = pram_find_data_block(inode, iblock);
+
+ if (!block) {
+ if (!create) {
+ err = -ENODATA;
+ goto err;
+ }
+
+ err = pram_alloc_blocks(inode, iblock, 1);
+ if (err)
+ goto err;
+
+ block = pram_find_data_block(inode, iblock);
+ if (!block) {
+ err = -ENODATA;
+ goto err;
+ }
+ }
+
+ *data_block = block;
+ err = 0;
+
+ err:
+ mutex_unlock(PRAM_I(inode)-truncate_mutex);
+ return err;
+}
+
+
+static int __pram_get_block(struct inode *inode, pgoff_t pgoff, int create,
+ sector_t *result)
+{
+ int rc = 0;
+ sector_t iblock;
+
+ /* find starting block number to access */
+ iblock = (sector_t)pgoff (PAGE_CACHE_SHIFT - inode-i_blkbits);
+
+ rc = pram_find_and_alloc_blocks(inode, iblock, result, create);
+
+ if (rc == -ENODATA)
+ BUG_ON(create);
+
+ return rc;
+}
+
+int pram_get_xip_mem(struct address_space *mapping, pgoff_t pgoff, int create,
+ void **kmem, unsigned long *pfn)
+{
+ int rc;
+ sector_t block;
+
+ /* first, retrieve the block */
+ rc = __pram_get_block(mapping-host, pgoff, create, block);
+ if (rc)
+ goto exit;
+
+ *kmem = pram_get_block(mapping-host-i_sb, block);
+ *pfn = page_to_pfn(virt_to_page((unsigned long)*kmem));
+
+exit:
+ return rc;
+}
diff -Nurp linux-2.6.36-orig/fs/pramfs/xip.h linux-2.6.36/fs/pramfs/xip.h
--- linux-2.6.36-orig/fs/pramfs/xip.h 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/xip.h2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,24 @@
+/*
+ * FILE NAME fs/pramfs/xip.h
+ *
+ * BRIEF DESCRIPTION
+ *
+ * XIP operations.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifdef CONFIG_PRAMFS_XIP
+
+int pram_get_xip_mem(struct address_space *, pgoff_t, int, void **,
+ unsigned long *);
+
+#else
+
+#define pram_get_xip_mem NULL
+
+#endif
+
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 11/16 v4] pramfs: ACL management
From: Marco Stornelli marco.storne...@gmail.com
ACL operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/acl.c linux-2.6.36/fs/pramfs/acl.c
--- linux-2.6.36-orig/fs/pramfs/acl.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/acl.c2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,418 @@
+/*
+ * FILE NAME fs/pramfs/acl.c
+ *
+ * BRIEF MODULE DESCRIPTION
+ *
+ * POSIX ACL operations
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * based on fs/ext2/acl.c with the following copyright:
+ *
+ * Copyright (C) 2001-2003 Andreas Gruenbacher, agr...@suse.de
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/capability.h
+#include linux/init.h
+#include linux/sched.h
+#include linux/slab.h
+#include linux/fs.h
+#include pram.h
+#include xattr.h
+#include acl.h
+
+/*
+ * Load ACL information from filesystem.
+ */
+static struct posix_acl *pram_acl_load(const void *value, size_t size)
+{
+ const char *end = (char *)value + size;
+ int n, count;
+ struct posix_acl *acl;
+
+ if (!value)
+ return NULL;
+ if (size sizeof(struct pram_acl_header))
+return ERR_PTR(-EINVAL);
+ if (((struct pram_acl_header *)value)-a_version !=
+ cpu_to_be32(PRAM_ACL_VERSION))
+ return ERR_PTR(-EINVAL);
+ value = (char *)value + sizeof(struct pram_acl_header);
+ count = pram_acl_count(size);
+ if (count 0)
+ return ERR_PTR(-EINVAL);
+ if (count == 0)
+ return NULL;
+ acl = posix_acl_alloc(count, GFP_KERNEL);
+ if (!acl)
+ return ERR_PTR(-ENOMEM);
+ for (n = 0; n count; n++) {
+ struct pram_acl_entry *entry = (struct pram_acl_entry *)value;
+ if ((char *)value + sizeof(struct pram_acl_entry_short) end)
+ goto fail;
+ acl-a_entries[n].e_tag = be16_to_cpu(entry-e_tag);
+ acl-a_entries[n].e_perm = be16_to_cpu(entry-e_perm);
+ switch (acl-a_entries[n].e_tag) {
+ case ACL_USER_OBJ:
+ case ACL_GROUP_OBJ:
+ case ACL_MASK:
+ case ACL_OTHER:
+ value = (char *)value +
+ sizeof(struct pram_acl_entry_short);
+ acl-a_entries[n].e_id = ACL_UNDEFINED_ID;
+ break;
+ case ACL_USER:
+ case ACL_GROUP:
+ value = (char *)value + sizeof(struct pram_acl_entry);
+ if ((char *)value end)
+ goto fail;
+ acl-a_entries[n].e_id =
+ be32_to_cpu(entry-e_id);
+ break;
+ default:
+ goto fail;
+ }
+ }
+ if (value != end)
+ goto fail;
+ return acl;
+
+fail:
+ posix_acl_release(acl);
+ return ERR_PTR(-EINVAL);
+}
+
+/*
+ * Save ACL information into the filesystem.
+ */
+static void *pram_acl_save(const struct posix_acl *acl, size_t *size)
+{
+ struct pram_acl_header *ext_acl;
+ char *e;
+ size_t n;
+
+ *size = pram_acl_size(acl-a_count);
+ ext_acl = kmalloc(sizeof(struct pram_acl_header) + acl-a_count *
+ sizeof(struct pram_acl_entry), GFP_KERNEL);
+ if (!ext_acl)
+ return ERR_PTR(-ENOMEM);
+ ext_acl-a_version = cpu_to_be32(PRAM_ACL_VERSION);
+ e = (char *)ext_acl + sizeof(struct pram_acl_header);
+ for (n = 0; n acl-a_count; n++) {
+ struct pram_acl_entry *entry = (struct pram_acl_entry *)e;
+ entry-e_tag = cpu_to_be16(acl-a_entries[n].e_tag);
+ entry-e_perm = cpu_to_be16(acl-a_entries[n].e_perm);
+ switch (acl-a_entries[n].e_tag) {
+ case ACL_USER:
+ case ACL_GROUP:
+ entry-e_id =
+ cpu_to_be32(acl-a_entries[n].e_id);
+ e += sizeof(struct pram_acl_entry);
+ break;
+ case ACL_USER_OBJ:
+ case ACL_GROUP_OBJ:
+ case ACL_MASK:
+ case ACL_OTHER:
+ e += sizeof(struct pram_acl_entry_short);
+ break;
+ default:
+ goto fail;
+ }
+ }
+ return (char *)ext_acl;
+
+fail:
+ kfree(ext_acl);
+ return ERR_PTR(-EINVAL);
+}
+
+/*
+ * inode-i_mutex: don't care
+ */
+static struct posix_acl *pram_get_acl(struct inode *inode, int type)
+{
+ int name_index;
+ char *value = NULL;
+ struct posix_acl
[PATCH 13/16 v4] pramfs: xattr block descriptors tree
From: Marco Stornelli marco.storne...@gmail.com
Extended attributes block descriptors tree.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/desctree.c
linux-2.6.36/fs/pramfs/desctree.c
--- linux-2.6.36-orig/fs/pramfs/desctree.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/desctree.c 2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,183 @@
+/*
+ * FILE NAME fs/pramfs/desctree.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Extended attributes block descriptors tree.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/spinlock.h
+#include desctree.h
+#include pram.h
+
+/* xblock_desc_init_always()
+ *
+ * These are initializations that need to be done on every
+ * descriptor allocation as the fields are not initialised
+ * by slab allocation.
+ */
+void xblock_desc_init_always(struct pram_xblock_desc *desc)
+{
+ atomic_set(desc-refcount, 0);
+ desc-blocknr = 0;
+ desc-flags = 0;
+}
+
+/* xblock_desc_init_once()
+ *
+ * These are initializations that only need to be done
+ * once, because the fields are idempotent across use
+ * of the descriptor, so let the slab aware of that.
+ */
+void xblock_desc_init_once(struct pram_xblock_desc *desc)
+{
+ mutex_init(desc-lock);
+}
+
+/* __insert_xblock_desc()
+ *
+ * Insert a new descriptor in the tree.
+ */
+static void __insert_xblock_desc(struct pram_sb_info *sbi,
+unsigned long blocknr, struct rb_node *node)
+{
+ struct rb_node **p = (sbi-desc_tree.rb_node);
+ struct rb_node *parent = NULL;
+ struct pram_xblock_desc *desc;
+
+ while (*p) {
+ parent = *p;
+ desc = rb_entry(parent, struct pram_xblock_desc, node);
+
+ if (blocknr desc-blocknr)
+ p = (*p)-rb_left;
+ else if (blocknr desc-blocknr)
+ p = (*p)-rb_right;
+ else
+ /* Oops...an other descriptor for the same block ? */
+ BUG();
+ }
+
+ rb_link_node(node, parent, p);
+ rb_insert_color(node, sbi-desc_tree);
+}
+
+void insert_xblock_desc(struct pram_sb_info *sbi, struct pram_xblock_desc
*desc)
+{
+ spin_lock(sbi-desc_tree_lock);
+ __insert_xblock_desc(sbi, desc-blocknr, desc-node);
+ spin_unlock(sbi-desc_tree_lock);
+};
+
+/* __lookup_xblock_desc()
+ *
+ * Search an extended attribute descriptor in the tree via the
+ * block number. It returns the descriptor if it's found or
+ * NULL. If not found it creates a new descriptor if create is not 0.
+ */
+static struct pram_xblock_desc *__lookup_xblock_desc(struct pram_sb_info *sbi,
+ unsigned long blocknr,
+ struct kmem_cache *cache,
+ int create)
+{
+ struct rb_node *n = sbi-desc_tree.rb_node;
+ struct pram_xblock_desc *desc = NULL;
+
+ while (n) {
+ desc = rb_entry(n, struct pram_xblock_desc, node);
+
+ if (blocknr desc-blocknr)
+ n = n-rb_left;
+ else if (blocknr desc-blocknr)
+ n = n-rb_right;
+ else {
+ atomic_inc(desc-refcount);
+ goto out;
+ }
+ }
+
+ /* not found */
+ if (create) {
+ desc = kmem_cache_alloc(cache, GFP_NOFS);
+ if (!desc)
+ return ERR_PTR(-ENOMEM);
+ xblock_desc_init_always(desc);
+ atomic_set(desc-refcount, 1);
+ desc-blocknr = blocknr;
+ __insert_xblock_desc(sbi, desc-blocknr, desc-node);
+ }
+out:
+ return desc;
+}
+
+struct pram_xblock_desc *lookup_xblock_desc(struct pram_sb_info *sbi,
+ unsigned long blocknr,
+ struct kmem_cache *cache,
+ int create)
+{
+ struct pram_xblock_desc *desc = NULL;
+
+ spin_lock(sbi-desc_tree_lock);
+ desc = __lookup_xblock_desc(sbi, blocknr, cache, create);
+ spin_unlock(sbi-desc_tree_lock);
+ return desc;
+}
+
+/* put_xblock_desc()
+ *
+ * Decrement the reference count and if it reaches zero and the
+ * desciptor has been marked to be free, then we free it.
+ * It returns 0 if the descriptor has been deleted and 1 otherwise.
+ */
+int put_xblock_desc(struct pram_sb_info *sbi, struct pram_xblock_desc *desc)
+{
+ int ret = 1;
+ if (!desc)
+ return ret;
+
+ if (atomic_dec_and_lock(desc-refcount, sbi-desc_tree_lock
[PATCH 14/16 v4] pramfs: write protection
From: Marco Stornelli marco.storne...@gmail.com
Memory write protection.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/wprotect.c
linux-2.6.36/fs/pramfs/wprotect.c
--- linux-2.6.36-orig/fs/pramfs/wprotect.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/wprotect.c 2010-10-30 11:59:54.0 +0200
@@ -0,0 +1,41 @@
+/*
+ * FILE NAME fs/pramfs/wprotect.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Write protection for the filesystem pages.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/module.h
+#include linux/fs.h
+#include linux/mm.h
+#include linux/io.h
+#include pram.h
+
+void pram_writeable(void *vaddr, unsigned long size, int rw)
+{
+ int ret = 0;
+ unsigned long nrpages = size PAGE_SHIFT;
+ unsigned long addr = (unsigned long)vaddr;
+
+ /* Page aligned */
+ addr = PAGE_MASK;
+
+ if (size (PAGE_SIZE - 1))
+ nrpages++;
+
+ if (rw)
+ ret = set_memory_rw(addr, nrpages);
+ else
+ ret = set_memory_ro(addr, nrpages);
+
+ BUG_ON(ret);
+}
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 15/16 v4] pramfs: test module
From: Marco Stornelli marco.storne...@gmail.com
Test module.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/pramfs_test.c
linux-2.6.36/fs/pramfs/pramfs_test.c
--- linux-2.6.36-orig/fs/pramfs/pramfs_test.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/pramfs_test.c2010-09-14 18:49:52.0
+0200
@@ -0,0 +1,49 @@
+/*
+ * FILE NAME fs/pramfs/pramfs_test.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Pramfs test module.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/module.h
+#include linux/version.h
+#include linux/init.h
+#include linux/fs.h
+#include pram.h
+
+int __init test_pramfs_write(void)
+{
+ struct pram_super_block *psb;
+
+ psb = get_pram_super();
+ if (!psb) {
+ printk(KERN_ERR
+ %s: PRAMFS super block not found (not mounted?)\n,
+ __func__);
+ return 1;
+ }
+
+ /*
+* Attempt an unprotected clear of checksum information in the
+* superblock, this should cause a kernel page protection fault.
+*/
+ printk(%s: writing to kernel VA %p\n, __func__, psb);
+ psb-s_sum = 0;
+
+ return 0;
+}
+
+void test_pramfs_write_cleanup(void) {}
+
+/* Module information */
+MODULE_LICENSE(GPL);
+module_init(test_pramfs_write);
+module_exit(test_pramfs_write_cleanup);
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 16/16 v4] pramfs: makefile and Kconfig
From: Marco Stornelli marco.storne...@gmail.com Makefile and Kconfig. Signed-off-by: Marco Stornelli marco.storne...@gmail.com --- diff -Nurp linux-2.6.36-orig/fs/Makefile linux-2.6.36/fs/Makefile --- linux-2.6.36-orig/fs/Makefile 2010-09-13 01:07:37.0 +0200 +++ linux-2.6.36/fs/Makefile2010-09-14 18:49:52.0 +0200 @@ -126,3 +126,4 @@ obj-$(CONFIG_BTRFS_FS) += btrfs/ obj-$(CONFIG_GFS2_FS) += gfs2/ obj-$(CONFIG_EXOFS_FS) += exofs/ obj-$(CONFIG_CEPH_FS) += ceph/ +obj-$(CONFIG_PRAMFS) += pramfs/ diff -Nurp linux-2.6.36-orig/fs/Kconfig linux-2.6.36/fs/Kconfig --- linux-2.6.36-orig/fs/Kconfig2010-09-13 01:07:37.0 +0200 +++ linux-2.6.36/fs/Kconfig 2010-09-14 18:49:52.0 +0200 @@ -13,7 +13,7 @@ source fs/ext4/Kconfig config FS_XIP # execute in place bool - depends on EXT2_FS_XIP + depends on EXT2_FS_XIP || PRAMFS_XIP default y source fs/jbd/Kconfig @@ -25,13 +25,14 @@ config FS_MBCACHE default y if EXT2_FS=y EXT2_FS_XATTR default y if EXT3_FS=y EXT3_FS_XATTR default y if EXT4_FS=y EXT4_FS_XATTR - default m if EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4_FS_XATTR + default y if PRAMFS=y PRAMFS_XATTR + default m if EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4_FS_XATTR || PRAMFS_XATTR source fs/reiserfs/Kconfig source fs/jfs/Kconfig config FS_POSIX_ACL -# Posix ACL utility routines (for now, only ext2/ext3/jfs/reiserfs/nfs4) +# Posix ACL utility routines (for now, only ext2/ext3/jfs/reiserfs/nfs4/pramfs) # # NOTE: you can implement Posix ACLs without these helpers (XFS does). # Never use this symbol for ifdefs. @@ -189,6 +190,7 @@ source fs/romfs/Kconfig source fs/sysv/Kconfig source fs/ufs/Kconfig source fs/exofs/Kconfig +source fs/pramfs/Kconfig endif # MISC_FILESYSTEMS diff -Nurp linux-2.6.36-orig/fs/pramfs/Kconfig linux-2.6.36/fs/pramfs/Kconfig --- linux-2.6.36-orig/fs/pramfs/Kconfig 1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/fs/pramfs/Kconfig 2010-10-30 10:30:19.0 +0200 @@ -0,0 +1,72 @@ +config PRAMFS + tristate Persistent and Protected RAM file system support + depends on HAS_IOMEM EXPERIMENTAL + select CRC16 + help + If your system has a block of fast (comparable in access speed to + system memory) and non-volatile RAM and you wish to mount a + light-weight, full-featured, and space-efficient filesystem over it, + say Y here, and read file:Documentation/filesystems/pramfs.txt. + + To compile this as a module, choose M here: the module will be + called pramfs. + +config PRAMFS_XIP + bool Enable Execute-in-place in PRAMFS + depends on PRAMFS !PRAMFS_WRITE_PROTECT + help + Say Y here to enable XIP feature of PRAMFS. + +config PRAMFS_WRITE_PROTECT + bool Enable PRAMFS write protection + depends on PRAMFS MMU HAVE_SET_MEMORY_RO + default y + help + Say Y here to enable the write protect feature of PRAMFS. + +config PRAMFS_XATTR + bool PRAMFS extended attributes + depends on PRAMFS + help + Extended attributes are name:value pairs associated with inodes by + the kernel or by users (see the attr(5) manual page, or visit + http://acl.bestbits.at/ for details). + + If unsure, say N. + +config PRAMFS_POSIX_ACL + bool PRAMFS POSIX Access Control Lists + depends on PRAMFS_XATTR + select FS_POSIX_ACL + help + Posix Access Control Lists (ACLs) support permissions for users and + groups beyond the owner/group/world scheme. + + To learn more about Access Control Lists, visit the Posix ACLs for + Linux website http://acl.bestbits.at/. + + If you don't know what Access Control Lists are, say N. + +config PRAMFS_SECURITY + bool PRAMFS Security Labels + depends on PRAMFS_XATTR + help + Security labels support alternative access control models + implemented by security modules like SELinux. This option + enables an extended attribute handler for file security + labels in the pram filesystem. + + If you are not using a security module that requires using + extended attributes for file security labels, say N. + +config PRAMFS_TEST + boolean + depends on PRAMFS + +config PRAMFS_TEST_MODULE + tristate PRAMFS Test + depends on PRAMFS m + select PRAMFS_TEST + help + Say Y here to build a simple module to test the protection of + PRAMFS. The module will be called pramfs_test. diff -Nurp linux-2.6.36-orig/fs/pramfs/Makefile linux-2.6.36/fs/pramfs/Makefile --- linux-2.6.36-orig/fs/pramfs/Makefile1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/fs/pramfs/Makefile 2010-09-14 18:49:52.0 +0200 @@ -0,0 +1,14 @@ +# +# Makefile
Re: [PATCH 02/16 v3] pramfs: super operations
2010/11/15 yidong zhang zhang...@gmail.com:
hi Marco
+ retval = 0;
+ out:
+ if (retval sbi-virt_addr) {
+ iounmap(sbi-virt_addr);
+ release_mem_region(sbi-phys_addr, initsize);
+ kfree(sbi);
+ }
+
+ return retval;
+}
+
I think kfree(sbi) should not be put here. In case of
pram_parse_options failure, sbi should also be freed too. How about
change it to the list below? And change some “goto out” branches to
“goto out_free”.
// retval = 0;
return 0;
out:
if (retval sbi-virt_addr) {
iounmap(sbi-virt_addr);
release_mem_region(sbi-phys_addr, initsize);
}
out_free:
kfree(sbi);
return retval;
}
Yeah, you're right. It's not always true that virt addr is valid,
kfree should be used out of this if. I'll fix it.
Marco
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 00/16 v3] pramfs: persistent and protected RAM filesystem
Hi all, third round for the patch series (I hope this is the last one :)). I summarize here the changes to improve the review: v3: - fix a possible memory leak in an error path reported by yidong zhang - fix a warning when using XIP about not used __pram_mmap symbol - fix test module header description and replaced TEST_MODULE with PRAMFS_TEST_MODULE in the Kconfig and Makefile according to the comments done by Randy Dunlap - fix a compilation warning in super.c reported by James Hogan - fix a compilation error when XIP was enabled - removed not used symbol PRAM_XATTR_INDEX_LUSTRE - fix some comment style issue v2: - fix documentation errors reported by Randy Dunlap and Kieran Bingham - reworked memory write protection functions with the suggestions of Andi Kleen v1: - first draft Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 01/16 v3] pramfs; documentation
From: Marco Stornelli marco.storne...@gmail.com Documentation for PRAMFS. Signed-off-by: Marco Stornelli marco.storne...@gmail.com --- diff -Nurp linux-2.6.36-orig/Documentation/filesystems/pramfs.txt linux-2.6.36/Documentation/filesystems/pramfs.txt --- linux-2.6.36-orig/Documentation/filesystems/pramfs.txt 1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/Documentation/filesystems/pramfs.txt 2010-10-23 09:04:32.0 +0200 @@ -0,0 +1,296 @@ + +PRAMFS Overview +=== + +Many embedded systems have a block of non-volatile RAM separate from +normal system memory, i.e. of which the kernel maintains no memory page +descriptors. For such systems it would be beneficial to mount a +fast read/write filesystem over this I/O memory, for storing frequently +accessed data that must survive system reboots and power cycles. An +example usage might be system logs under /var/log, or a user address +book in a cell phone or PDA. + +Linux traditionally had no support for a persistent, non-volatile RAM-based +filesystem, persistent meaning the filesystem survives a system reboot +or power cycle intact. The RAM-based filesystems such as tmpfs and ramfs +have no actual backing store but exist entirely in the page and buffer +caches, hence the filesystem disappears after a system reboot or +power cycle. + +A relatively straightforward solution is to write a simple block driver +for the non-volatile RAM, and mount over it any disk-based filesystem such +as ext2, ext3, ext4, etc. + +But the disk-based fs over non-volatile RAM block driver approach has +some drawbacks: + +1. Complexity of disk-based fs: disk-based filesystems such as ext2/ext3/ext4 + were designed for optimum performance on spinning disk media, so they + implement features such as block groups, which attempts to group inode data + into a contiguous set of data blocks to minimize disk seeking when accessing + files. For RAM there is no such concern; a file's data blocks can be + scattered throughout the media with no access speed penalty at all. So block + groups in a filesystem mounted over RAM just adds unnecessary + complexity. A better approach is to use a filesystem specifically + tailored to RAM media which does away with these disk-based features. + This increases the efficient use of space on the media, i.e. more + space is dedicated to actual file data storage and less to meta-data + needed to maintain that file data. + +2. Different problems between disks and RAM: Because PRAMFS attempts to avoid + filesystem corruption caused by kernel bugs, dirty pages in the page cache + are not allowed to be written back to the backing-store RAM. This way, an + errant write into the page cache will not get written back to the filesystem. + However, if the backing-store RAM is comparable in access speed to system + memory, the penalty of not using caching is minimal. With this consideration + it's better to move file data directly between the user buffers and the backing + store RAM, i.e. use direct I/O. This prevents the unnecessary populating of + the page cache with dirty pages. However direct I/O has to be enabled at + every file open. To enable direct I/O at all times for all regular files + requires either that applications be modified to include the O_DIRECT flag on + all file opens, or that the filesystem used performs direct I/O by default. + +The Persistent/Protected RAM Special Filesystem (PRAMFS) is a read/write +filesystem that has been designed to address these issues. PRAMFS is targeted +to fast I/O memory, and if the memory is non-volatile, the filesystem will be +persistent. + +In PRAMFS, direct I/O is enabled across all files in the filesystem, in other +words the O_DIRECT flag is forced on every open of a PRAMFS file. Also, file +I/O in the PRAMFS is always synchronous. There is no need to block the current +process while the transfer to/from the PRAMFS is in progress, since one of +the requirements of the PRAMFS is that the filesystem exists in fast RAM. So +file I/O in PRAMFS is always direct, synchronous, and never blocks. + +The data organization in PRAMFS can be thought of as an extremely simplified +version of ext2, such that the ratio of data to meta-data is very high. + +PRAMFS supports the execute-in-place. With XIP, instead of keeping data in the +page cache, the need to have a page cache copy is eliminated completely. +Readwrite type operations are performed directly from/to the memory. For file +mappings, the RAM itself is mapped directly into userspace. XIP, in addition, +speed up the applications start-up time because it removes the needs of any +copies. + +PRAMFS is write protected. The page table entries that map the backing-store +RAM are normally marked read-only. Write operations into the filesystem +temporarily mark the affected pages as writeable, the write operation is +carried out with locks held, and then the page table entries is +marked read-only
[PATCH 03/16 v3] pramfs: inode operations
From: Marco Stornelli marco.storne...@gmail.com
Inode methods (allocate/free/read/write).
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/inode.c linux-2.6.36/fs/pramfs/inode.c
--- linux-2.6.36-orig/fs/pramfs/inode.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/inode.c 2010-09-26 18:04:38.0 +0200
@@ -0,0 +1,710 @@
+/*
+ * FILE NAME fs/pramfs/inode.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Inode methods (allocate/free/read/write).
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/smp_lock.h
+#include linux/sched.h
+#include linux/highuid.h
+#include linux/quotaops.h
+#include linux/module.h
+#include linux/mpage.h
+#include linux/backing-dev.h
+#include pram.h
+#include xattr.h
+#include xip.h
+#include acl.h
+
+struct backing_dev_info pram_backing_dev_info __read_mostly = {
+ .ra_pages = 0,/* No readahead */
+ .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK,
+};
+
+/*
+ * allocate a data block for inode and return it's absolute blocknr.
+ * Zeroes out the block if zero set. Increments inode-i_blocks.
+ */
+static int pram_new_data_block(struct inode *inode, unsigned long *blocknr,
int zero)
+{
+ int errval = pram_new_block(inode-i_sb, blocknr, zero);
+
+ if (!errval) {
+ struct pram_inode *pi = pram_get_inode(inode-i_sb,
+ inode-i_ino);
+ inode-i_blocks++;
+ pram_memunlock_inode(pi);
+ pi-i_blocks = cpu_to_be32(inode-i_blocks);
+ pram_memlock_inode(pi);
+ }
+
+ return errval;
+}
+
+/*
+ * find the offset to the block represented by the given inode's file
+ * relative block number.
+ */
+u64 pram_find_data_block(struct inode *inode, int file_blocknr)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *pi;
+ u64 *row; /* ptr to row block */
+ u64 *col; /* ptr to column blocks */
+ u64 bp = 0;
+ int i_row, i_col;
+ int N = sb-s_blocksize 3; /* num block ptrs per block */
+ int Nbits = sb-s_blocksize_bits - 3;
+
+ pi = pram_get_inode(sb, inode-i_ino);
+
+ i_row = file_blocknr Nbits;
+ i_col = file_blocknr (N-1);
+
+ row = pram_get_block(sb, be64_to_cpu(pi-i_type.reg.row_block));
+ if (row) {
+ col = pram_get_block(sb, be64_to_cpu(row[i_row]));
+ if (col)
+ bp = be64_to_cpu(col[i_col]);
+ }
+
+ return bp;
+}
+
+/*
+ * Free data blocks from inode in the range start = end
+ */
+static void __pram_truncate_blocks(struct inode *inode, loff_t start, loff_t
end)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *pi = pram_get_inode(sb, inode-i_ino);
+ int N = sb-s_blocksize 3; /* num block ptrs per block */
+ int Nbits = sb-s_blocksize_bits - 3;
+ int first_row_index, last_row_index, i, j;
+ unsigned long blocknr, first_blocknr, last_blocknr;
+ unsigned int freed = 0;
+ u64 *row; /* ptr to row block */
+ u64 *col; /* ptr to column blocks */
+
+ if (start end || !inode-i_blocks || !pi-i_type.reg.row_block)
+ return;
+
+ mutex_lock(PRAM_I(inode)-truncate_mutex);
+
+ first_blocknr = (start + sb-s_blocksize - 1) sb-s_blocksize_bits;
+ last_blocknr = (end + sb-s_blocksize - 1) sb-s_blocksize_bits;
+ first_row_index = first_blocknr Nbits;
+ last_row_index = last_blocknr Nbits;
+
+ row = pram_get_block(sb, be64_to_cpu(pi-i_type.reg.row_block));
+
+ for (i = first_row_index; i = last_row_index; i++) {
+ int first_col_index = (i == first_row_index) ?
+ first_blocknr (N-1) : 0;
+ int last_col_index = (i == last_row_index) ?
+ last_blocknr (N-1) : N-1;
+
+ if (unlikely(!row[i]))
+ continue;
+
+ col = pram_get_block(sb, be64_to_cpu(row[i]));
+
+ for (j = first_col_index; j = last_col_index; j++) {
+
+ if (unlikely(!col[j]))
+ continue;
+
+ blocknr = pram_get_blocknr(sb, be64_to_cpu(col[j]));
+ pram_free_block(sb, blocknr);
+ freed++;
+ pram_memunlock_block(sb, col);
+ col[j] = 0;
+ pram_memlock_block(sb, col);
+ }
+
+ if (first_col_index == 0
[PATCH 04/16 v3] pramfs: file operations
From: Marco Stornelli marco.storne...@gmail.com
File operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/file.c linux-2.6.36/fs/pramfs/file.c
--- linux-2.6.36-orig/fs/pramfs/file.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/file.c 2010-09-24 18:34:03.0 +0200
@@ -0,0 +1,166 @@
+/*
+ * FILE NAME fs/pramfs/file.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * File operations for files.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/fs.h
+#include linux/sched.h
+#include linux/slab.h
+#include linux/uio.h
+#include linux/mm.h
+#include linux/uaccess.h
+#include pram.h
+#include acl.h
+#include xip.h
+#include xattr.h
+
+static int pram_open_file(struct inode *inode, struct file *filp)
+{
+#ifndef CONFIG_PRAMFS_XIP
+ /* Without XIP we force to use Direct IO */
+ filp-f_flags |= O_DIRECT;
+#endif
+ return generic_file_open(inode, filp);
+}
+
+ssize_t __pram_direct_IO(int rw, struct kiocb *iocb,
+ const struct iovec *iov,
+ loff_t offset, unsigned long nr_segs)
+{
+ struct file *file = iocb-ki_filp;
+ struct inode *inode = file-f_mapping-host;
+ struct super_block *sb = inode-i_sb;
+ int progress = 0, hole = 0;
+ ssize_t retval = 0;
+ void *tmp = NULL;
+ unsigned long blocknr, blockoff;
+ int num_blocks, blocksize_mask, blocksize, blocksize_bits;
+ char __user *buf = iov-iov_base;
+ size_t length = iov_length(iov, nr_segs);
+
+ if (length 0)
+ return -EINVAL;
+ if ((rw == READ) (offset + length inode-i_size))
+ length = inode-i_size - offset;
+ if (!length)
+ goto out;
+
+ blocksize_bits = inode-i_sb-s_blocksize_bits;
+ blocksize = 1 blocksize_bits;
+ blocksize_mask = blocksize - 1;
+
+ /* find starting block number to access */
+ blocknr = offset blocksize_bits;
+ /* find starting offset within starting block */
+ blockoff = offset blocksize_mask;
+ /* find number of blocks to access */
+ num_blocks = (blockoff + length + blocksize_mask) blocksize_bits;
+
+ if (rw == WRITE) {
+ /* prepare a temporary buffer to hold a user data block
+ for writing. */
+ tmp = kmalloc(blocksize, GFP_KERNEL);
+ if (!tmp)
+ return -ENOMEM;
+ /* now allocate the data blocks we'll need */
+ retval = pram_alloc_blocks(inode, blocknr, num_blocks);
+ if (retval)
+ goto fail1;
+ }
+
+ while (length) {
+ int count;
+ u8 *bp = NULL;
+ u64 block = pram_find_data_block(inode, blocknr++);
+ if (unlikely(!block rw == READ)) {
+ /* We are falling in a hole */
+ hole = 1;
+ } else {
+ bp = (u8 *)pram_get_block(sb, block);
+ if (!bp)
+ goto fail2;
+ }
+
+ count = blockoff + length blocksize ?
+ blocksize - blockoff : length;
+
+ if (rw == READ) {
+ if (unlikely(hole)) {
+ retval = clear_user(buf, count);
+ if (retval) {
+ retval = -EFAULT;
+ goto fail1;
+ }
+ } else {
+ retval = copy_to_user(buf, bp[blockoff],
count);
+ if (retval) {
+ retval = -EFAULT;
+ goto fail1;
+ }
+ }
+ } else {
+ retval = copy_from_user(tmp, buf, count);
+ if (retval) {
+ retval = -EFAULT;
+ goto fail1;
+ }
+
+ pram_memunlock_block(inode-i_sb, bp);
+ memcpy(bp[blockoff], tmp, count);
+ pram_memlock_block(inode-i_sb, bp);
+ }
+
+ progress += count;
+ buf += count;
+ length -= count;
+ blockoff = 0;
+ hole = 0;
+ }
+
+fail2:
+ retval = progress;
+fail1:
+ kfree(tmp);
+out
[PATCH 07/16 v3] pramfs: symbolic links
From: Marco Stornelli marco.storne...@gmail.com
Symlink operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/symlink.c
linux-2.6.36/fs/pramfs/symlink.c
--- linux-2.6.36-orig/fs/pramfs/symlink.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/symlink.c2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,78 @@
+/*
+ * FILE NAME fs/pramfs/symlink.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Symlink operations
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include pram.h
+#include xattr.h
+
+int pram_block_symlink(struct inode *inode, const char *symname, int len)
+{
+ struct super_block *sb = inode-i_sb;
+ u64 block;
+ char *blockp;
+ int err;
+
+ err = pram_alloc_blocks(inode, 0, 1);
+ if (err)
+ return err;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+
+ pram_memunlock_block(sb, blockp);
+ memcpy(blockp, symname, len);
+ blockp[len] = '\0';
+ pram_memlock_block(sb, blockp);
+ return 0;
+}
+
+static int pram_readlink(struct dentry *dentry, char *buffer, int buflen)
+{
+ struct inode *inode = dentry-d_inode;
+ struct super_block *sb = inode-i_sb;
+ u64 block;
+ char *blockp;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+ return vfs_readlink(dentry, buffer, buflen, blockp);
+}
+
+static void *pram_follow_link(struct dentry *dentry, struct nameidata *nd)
+{
+ struct inode *inode = dentry-d_inode;
+ struct super_block *sb = inode-i_sb;
+ off_t block;
+ int status;
+ char *blockp;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+ status = vfs_follow_link(nd, blockp);
+ return ERR_PTR(status);
+}
+
+struct inode_operations pram_symlink_inode_operations = {
+ .readlink = pram_readlink,
+ .follow_link= pram_follow_link,
+ .setattr= pram_notify_change,
+#ifdef CONFIG_PRAMFS_XATTR
+ .setxattr = generic_setxattr,
+ .getxattr = generic_getxattr,
+ .listxattr = pram_listxattr,
+ .removexattr= generic_removexattr,
+#endif
+};
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 08/16 v3] pramfs: headers
From: Marco Stornelli marco.storne...@gmail.com
Definitions for the PRAMFS filesystem.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/pram.h linux-2.6.36/fs/pramfs/pram.h
--- linux-2.6.36-orig/fs/pramfs/pram.h 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/pram.h 2010-10-30 12:02:45.0 +0200
@@ -0,0 +1,317 @@
+/*
+ * FILE NAME pram.h
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Definitions for the PRAMFS filesystem.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#ifndef __PRAM_H
+#define __PRAM_H
+
+#include linux/buffer_head.h
+#include linux/pram_fs.h
+#include linux/pram_fs_sb.h
+#include linux/crc16.h
+#include linux/mutex.h
+#include linux/types.h
+
+/*
+ * Debug code
+ */
+#define pram_dbg(s, args...) pr_debug(PRAMFS: s, ## args)
+#define pram_err(s, args...) pr_err(PRAMFS: s, ## args)
+#define pram_warn(s, args...) pr_warning(PRAMFS: s, ## args)
+#define pram_info(s, args...) pr_info(PRAMFS: s, ## args)
+
+/* Function Prototypes */
+
+#ifdef CONFIG_PRAMFS_XIP
+
+#define pram_read xip_file_read
+#define pram_write xip_file_write
+#define pram_mmap xip_file_mmap
+#define pram_aio_read NULL
+#define pram_aio_write NULL
+#define pram_readpage NULL
+#define pram_direct_IO NULL
+
+#else
+
+#define pram_read do_sync_read
+#define pram_write do_sync_write
+#define pram_mmap __pram_mmap
+#define pram_aio_read generic_file_aio_read
+#define pram_aio_write generic_file_aio_write
+#define pram_direct_IO __pram_direct_IO
+#define pram_readpage __pram_readpage
+
+extern int pram_get_and_update_block(struct inode *inode, sector_t iblock,
+struct buffer_head *bh, int create);
+
+static inline int __pram_readpage(struct file *file, struct page *page)
+{
+ return block_read_full_page(page, pram_get_and_update_block);
+}
+
+/* file.c */
+extern ssize_t __pram_direct_IO(int rw, struct kiocb *iocb,
+ const struct iovec *iov,
+ loff_t offset, unsigned long nr_segs);
+extern int __pram_mmap(struct file *file, struct vm_area_struct *vma);
+
+#endif /* CONFIG_PRAMFS_XIP */
+
+#define pram_set_bit ext2_set_bit
+#define pram_clear_bit ext2_clear_bit
+#define pram_find_next_zero_bitext2_find_next_zero_bit
+
+/* balloc.c */
+extern void pram_init_bitmap(struct super_block *sb);
+extern void pram_free_block(struct super_block *sb, unsigned long blocknr);
+extern int pram_new_block(struct super_block *sb, unsigned long *blocknr, int
zero);
+extern unsigned long pram_count_free_blocks(struct super_block *sb);
+
+/* dir.c */
+extern int pram_add_link(struct dentry *dentry, struct inode *inode);
+extern int pram_remove_link(struct inode *inode);
+
+/* namei.c */
+extern struct dentry *pram_get_parent(struct dentry *child);
+
+/* inode.c */
+extern int pram_alloc_blocks(struct inode *inode, int file_blocknr, int num);
+extern u64 pram_find_data_block(struct inode *inode,
+int file_blocknr);
+
+extern struct inode *pram_iget(struct super_block *sb, unsigned long ino);
+extern void pram_put_inode(struct inode *inode);
+extern void pram_evict_inode(struct inode *inode);
+extern struct inode *pram_new_inode(struct inode *dir, int mode);
+extern int pram_update_inode(struct inode *inode);
+extern int pram_write_inode(struct inode *inode, struct writeback_control
*wbc);
+extern void pram_dirty_inode(struct inode *inode);
+extern int pram_notify_change(struct dentry *dentry, struct iattr *attr);
+
+
+/* super.c */
+#ifdef CONFIG_PRAMFS_TEST
+extern struct pram_super_block *get_pram_super(void);
+#endif
+extern struct super_block *pram_read_super(struct super_block *sb,
+ void *data,
+ int silent);
+extern int pram_statfs(struct dentry *d, struct kstatfs *buf);
+extern int pram_remount(struct super_block *sb, int *flags, char *data);
+
+/* symlink.c */
+extern int pram_block_symlink(struct inode *inode,
+ const char *symname, int len);
+
+
+#ifdef CONFIG_PRAMFS_WRITE_PROTECT
+extern void pram_writeable(void *vaddr, unsigned long size, int rw);
+
+#define wrprotect(addr, size) pram_writeable(addr, size, 0)
+
+#else
+
+#define wrprotect(addr, size) do {} while (0)
+
+#endif /* CONFIG PRAMFS_WRITE_PROTECT */
+
+/* Inline functions start here */
+
+static inline int pram_calc_checksum(u8 *data, int n)
+{
+ u16 crc = 0;
+ crc = crc16(~0, (__u8 *)data + sizeof
[PATCH 09/16 v3] pramfs: dir operations
From: Marco Stornelli marco.storne...@gmail.com
File operations for directories.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/dir.c linux-2.6.36/fs/pramfs/dir.c
--- linux-2.6.36-orig/fs/pramfs/dir.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/dir.c2010-09-17 19:08:54.0 +0200
@@ -0,0 +1,215 @@
+/*
+ * FILE NAME fs/pramfs/dir.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * File operations for directories.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/pagemap.h
+#include pram.h
+
+/*
+ * Parent is locked.
+ */
+int pram_add_link(struct dentry *dentry, struct inode *inode)
+{
+ struct inode *dir = dentry-d_parent-d_inode;
+ struct pram_inode *pidir, *pi, *pitail = NULL;
+ u64 tail_ino, prev_ino;
+
+ const char *name = dentry-d_name.name;
+
+ int namelen = dentry-d_name.len PRAM_NAME_LEN ?
+ PRAM_NAME_LEN : dentry-d_name.len;
+
+ pidir = pram_get_inode(dir-i_sb, dir-i_ino);
+ pi = pram_get_inode(dir-i_sb, inode-i_ino);
+
+ dir-i_mtime = dir-i_ctime = CURRENT_TIME;
+
+ tail_ino = be64_to_cpu(pidir-i_type.dir.tail);
+ if (tail_ino != 0) {
+ pitail = pram_get_inode(dir-i_sb, tail_ino);
+ pram_memunlock_inode(pitail);
+ pitail-i_d.d_next = cpu_to_be64(inode-i_ino);
+ pram_memlock_inode(pitail);
+
+ prev_ino = tail_ino;
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = cpu_to_be64(inode-i_ino);
+ pidir-i_mtime = cpu_to_be32(dir-i_mtime.tv_sec);
+ pidir-i_ctime = cpu_to_be32(dir-i_ctime.tv_sec);
+ pram_memlock_inode(pidir);
+ } else {
+ /* the directory is empty */
+ prev_ino = 0;
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = cpu_to_be64(inode-i_ino);
+ pidir-i_type.dir.head = cpu_to_be64(inode-i_ino);
+ pidir-i_mtime = cpu_to_be32(dir-i_mtime.tv_sec);
+ pidir-i_ctime = cpu_to_be32(dir-i_ctime.tv_sec);
+ pram_memlock_inode(pidir);
+ }
+
+
+ pram_memunlock_inode(pi);
+ pi-i_d.d_prev = cpu_to_be64(prev_ino);
+ pi-i_d.d_parent = cpu_to_be64(dir-i_ino);
+ memcpy(pi-i_d.d_name, name, namelen);
+ pi-i_d.d_name[namelen] = '\0';
+ pram_memlock_inode(pi);
+ return 0;
+}
+
+int pram_remove_link(struct inode *inode)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *prev = NULL;
+ struct pram_inode *next = NULL;
+ struct pram_inode *pidir, *pi;
+
+ pi = pram_get_inode(sb, inode-i_ino);
+ pidir = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_parent));
+ if (!pidir)
+ return -EACCES;
+
+ if (inode-i_ino == be64_to_cpu(pidir-i_type.dir.head)) {
+ /* first inode in directory */
+ next = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_next));
+
+ if (next) {
+ pram_memunlock_inode(next);
+ next-i_d.d_prev = 0;
+ pram_memlock_inode(next);
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.head = pi-i_d.d_next;
+ } else {
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.head = 0;
+ pidir-i_type.dir.tail = 0;
+ }
+ pram_memlock_inode(pidir);
+ } else if (inode-i_ino == be64_to_cpu(pidir-i_type.dir.tail)) {
+ /* last inode in directory */
+ prev = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_prev));
+
+ pram_memunlock_inode(prev);
+ prev-i_d.d_next = 0;
+ pram_memlock_inode(prev);
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = pi-i_d.d_prev;
+ pram_memlock_inode(pidir);
+ } else {
+ /* somewhere in the middle */
+ prev = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_prev));
+ next = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_next));
+
+ if (prev next) {
+ pram_memunlock_inode(prev);
+ prev-i_d.d_next = pi-i_d.d_next;
+ pram_memlock_inode(prev);
+
+ pram_memunlock_inode(next);
+ next-i_d.d_prev = pi-i_d.d_prev
[PATCH 10/16 v3] pramfs: XIP operations
From: Marco Stornelli marco.storne...@gmail.com
XIP operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/xip.c linux-2.6.36/fs/pramfs/xip.c
--- linux-2.6.36-orig/fs/pramfs/xip.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/xip.c2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,90 @@
+/*
+ * FILE NAME fs/pramfs/xip.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * XIP operations.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/mm.h
+#include linux/fs.h
+#include linux/genhd.h
+#include linux/buffer_head.h
+#include pram.h
+#include xip.h
+
+static int pram_find_and_alloc_blocks(struct inode *inode, sector_t iblock,
+sector_t *data_block, int create)
+{
+ int err = -EIO;
+ u64 block;
+
+ mutex_lock(PRAM_I(inode)-truncate_mutex);
+
+ block = pram_find_data_block(inode, iblock);
+
+ if (!block) {
+ if (!create) {
+ err = -ENODATA;
+ goto err;
+ }
+
+ err = pram_alloc_blocks(inode, iblock, 1);
+ if (err)
+ goto err;
+
+ block = pram_find_data_block(inode, iblock);
+ if (!block) {
+ err = -ENODATA;
+ goto err;
+ }
+ }
+
+ *data_block = block;
+ err = 0;
+
+ err:
+ mutex_unlock(PRAM_I(inode)-truncate_mutex);
+ return err;
+}
+
+
+static int __pram_get_block(struct inode *inode, pgoff_t pgoff, int create,
+ sector_t *result)
+{
+ int rc = 0;
+ sector_t iblock;
+
+ /* find starting block number to access */
+ iblock = (sector_t)pgoff (PAGE_CACHE_SHIFT - inode-i_blkbits);
+
+ rc = pram_find_and_alloc_blocks(inode, iblock, result, create);
+
+ if (rc == -ENODATA)
+ BUG_ON(create);
+
+ return rc;
+}
+
+int pram_get_xip_mem(struct address_space *mapping, pgoff_t pgoff, int create,
+ void **kmem, unsigned long *pfn)
+{
+ int rc;
+ sector_t block;
+
+ /* first, retrieve the block */
+ rc = __pram_get_block(mapping-host, pgoff, create, block);
+ if (rc)
+ goto exit;
+
+ *kmem = pram_get_block(mapping-host-i_sb, block);
+ *pfn = page_to_pfn(virt_to_page((unsigned long)*kmem));
+
+exit:
+ return rc;
+}
diff -Nurp linux-2.6.36-orig/fs/pramfs/xip.h linux-2.6.36/fs/pramfs/xip.h
--- linux-2.6.36-orig/fs/pramfs/xip.h 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/xip.h2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,24 @@
+/*
+ * FILE NAME fs/pramfs/xip.h
+ *
+ * BRIEF DESCRIPTION
+ *
+ * XIP operations.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifdef CONFIG_PRAMFS_XIP
+
+int pram_get_xip_mem(struct address_space *, pgoff_t, int, void **,
+ unsigned long *);
+
+#else
+
+#define pram_get_xip_mem NULL
+
+#endif
+
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 12/16 v3] pramfs: extended attributes
From: Marco Stornelli marco.storne...@gmail.com
Extended attributes operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/xattr.c linux-2.6.36/fs/pramfs/xattr.c
--- linux-2.6.36-orig/fs/pramfs/xattr.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/xattr.c 2010-09-14 19:45:40.0 +0200
@@ -0,0 +1,1108 @@
+/*
+ * FILE NAME fs/pramfs/xattr.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Extended attributes operations.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * based on fs/ext2/xattr.c with the following copyright:
+ *
+ * Fix by Harrison Xing harri...@mountainviewdata.com.
+ * Extended attributes for symlinks and special files added per
+ * suggestion of Luka Renko luka.re...@hermes.si.
+ * xattr consolidation Copyright (c) 2004 James Morris jmor...@redhat.com,
+ * Red Hat Inc.
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+/*
+ * Extended attributes are stored in blocks allocated outside of
+ * any inode. The i_xattr field is then made to point to this allocated
+ * block. If all extended attributes of an inode are identical, these
+ * inodes may share the same extended attribute block. Such situations
+ * are automatically detected by keeping a cache of recent attribute block
+ * numbers and hashes over the block's contents in memory.
+ *
+ *
+ * Extended attribute block layout:
+ *
+ * +--+
+ * | header |
+ * | entry 1 | |
+ * | entry 2 | | growing downwards
+ * | entry 3 | v
+ * | four null bytes |
+ * | . . .|
+ * | value 1 | ^
+ * | value 3 | | growing upwards
+ * | value 2 | |
+ * +--+
+ *
+ * The block header is followed by multiple entry descriptors. These entry
+ * descriptors are variable in size, and alligned to PRAM_XATTR_PAD
+ * byte boundaries. The entry descriptors are sorted by attribute name,
+ * so that two extended attribute blocks can be compared efficiently.
+ *
+ * Attribute values are aligned to the end of the block, stored in
+ * no specific order. They are also padded to PRAM_XATTR_PAD byte
+ * boundaries. No additional gaps are left between them.
+ *
+ * Locking strategy
+ *
+ * pi-i_xattr is protected by PRAM_I(inode)-xattr_sem.
+ * EA blocks are only changed if they are exclusive to an inode, so
+ * holding xattr_sem also means that nothing but the EA block's reference
+ * count will change. Multiple writers to an EA block are synchronized
+ * by the mutex in each block descriptor. Block descriptors are kept in a
+ * red black tree and the key is the absolute block number.
+ */
+
+#include linux/module.h
+#include linux/init.h
+#include linux/mbcache.h
+#include linux/rwsem.h
+#include linux/security.h
+#include pram.h
+#include xattr.h
+#include acl.h
+#include desctree.h
+
+#define HDR(bp) ((struct pram_xattr_header *)(bp))
+#define ENTRY(ptr) ((struct pram_xattr_entry *)(ptr))
+#define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1)
+#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
+#define GET_DESC(sbi, blocknr) lookup_xblock_desc(sbi, blocknr,
pram_xblock_desc_cache, 1)
+#define LOOKUP_DESC(sbi, blocknr) lookup_xblock_desc(sbi, blocknr, NULL, 0)
+
+#ifdef PRAM_XATTR_DEBUG
+# define ea_idebug(inode, f...) do { \
+ printk(KERN_DEBUG inode %ld: , inode-i_ino); \
+ printk(f); \
+ printk(\n); \
+ } while (0)
+# define ea_bdebug(blocknr, f...) do { \
+ printk(KERN_DEBUG block %lu: , blocknr); \
+ printk(f); \
+ printk(\n); \
+ } while (0)
+#else
+# define ea_idebug(f...)
+# define ea_bdebug(f...)
+#endif
+
+static int pram_xattr_set2(struct inode *, char *, struct pram_xblock_desc *,
struct pram_xattr_header *);
+
+static int pram_xattr_cache_insert(struct super_block *sb, unsigned long
blocknr, u32 xhash);
+static struct pram_xblock_desc *pram_xattr_cache_find(struct inode *,
+struct pram_xattr_header *);
+static void pram_xattr_rehash(struct pram_xattr_header *,
+ struct pram_xattr_entry *);
+
+static struct mb_cache *pram_xattr_cache;
+static struct kmem_cache *pram_xblock_desc_cache;
+
+static const struct xattr_handler *pram_xattr_handler_map[] = {
+ [PRAM_XATTR_INDEX_USER] = pram_xattr_user_handler,
+#ifdef CONFIG_PRAMFS_POSIX_ACL
+ [PRAM_XATTR_INDEX_POSIX_ACL_ACCESS] = pram_xattr_acl_access_handler,
+ [PRAM_XATTR_INDEX_POSIX_ACL_DEFAULT] = pram_xattr_acl_default_handler,
+#endif
+ [PRAM_XATTR_INDEX_TRUSTED] = pram_xattr_trusted_handler,
+#ifdef CONFIG_PRAMFS_SECURITY
+ [PRAM_XATTR_INDEX_SECURITY] = pram_xattr_security_handler,
+#endif
+};
+
+const
[PATCH 13/16 v3] pramfs: xattr attributes block descriptors tree
From: Marco Stornelli marco.storne...@gmail.com
Extended attributes block descriptors tree.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/desctree.c
linux-2.6.36/fs/pramfs/desctree.c
--- linux-2.6.36-orig/fs/pramfs/desctree.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/desctree.c 2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,183 @@
+/*
+ * FILE NAME fs/pramfs/desctree.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Extended attributes block descriptors tree.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/spinlock.h
+#include desctree.h
+#include pram.h
+
+/* xblock_desc_init_always()
+ *
+ * These are initializations that need to be done on every
+ * descriptor allocation as the fields are not initialised
+ * by slab allocation.
+ */
+void xblock_desc_init_always(struct pram_xblock_desc *desc)
+{
+ atomic_set(desc-refcount, 0);
+ desc-blocknr = 0;
+ desc-flags = 0;
+}
+
+/* xblock_desc_init_once()
+ *
+ * These are initializations that only need to be done
+ * once, because the fields are idempotent across use
+ * of the descriptor, so let the slab aware of that.
+ */
+void xblock_desc_init_once(struct pram_xblock_desc *desc)
+{
+ mutex_init(desc-lock);
+}
+
+/* __insert_xblock_desc()
+ *
+ * Insert a new descriptor in the tree.
+ */
+static void __insert_xblock_desc(struct pram_sb_info *sbi,
+unsigned long blocknr, struct rb_node *node)
+{
+ struct rb_node **p = (sbi-desc_tree.rb_node);
+ struct rb_node *parent = NULL;
+ struct pram_xblock_desc *desc;
+
+ while (*p) {
+ parent = *p;
+ desc = rb_entry(parent, struct pram_xblock_desc, node);
+
+ if (blocknr desc-blocknr)
+ p = (*p)-rb_left;
+ else if (blocknr desc-blocknr)
+ p = (*p)-rb_right;
+ else
+ /* Oops...an other descriptor for the same block ? */
+ BUG();
+ }
+
+ rb_link_node(node, parent, p);
+ rb_insert_color(node, sbi-desc_tree);
+}
+
+void insert_xblock_desc(struct pram_sb_info *sbi, struct pram_xblock_desc
*desc)
+{
+ spin_lock(sbi-desc_tree_lock);
+ __insert_xblock_desc(sbi, desc-blocknr, desc-node);
+ spin_unlock(sbi-desc_tree_lock);
+};
+
+/* __lookup_xblock_desc()
+ *
+ * Search an extended attribute descriptor in the tree via the
+ * block number. It returns the descriptor if it's found or
+ * NULL. If not found it creates a new descriptor if create is not 0.
+ */
+static struct pram_xblock_desc *__lookup_xblock_desc(struct pram_sb_info *sbi,
+ unsigned long blocknr,
+ struct kmem_cache *cache,
+ int create)
+{
+ struct rb_node *n = sbi-desc_tree.rb_node;
+ struct pram_xblock_desc *desc = NULL;
+
+ while (n) {
+ desc = rb_entry(n, struct pram_xblock_desc, node);
+
+ if (blocknr desc-blocknr)
+ n = n-rb_left;
+ else if (blocknr desc-blocknr)
+ n = n-rb_right;
+ else {
+ atomic_inc(desc-refcount);
+ goto out;
+ }
+ }
+
+ /* not found */
+ if (create) {
+ desc = kmem_cache_alloc(cache, GFP_NOFS);
+ if (!desc)
+ return ERR_PTR(-ENOMEM);
+ xblock_desc_init_always(desc);
+ atomic_set(desc-refcount, 1);
+ desc-blocknr = blocknr;
+ __insert_xblock_desc(sbi, desc-blocknr, desc-node);
+ }
+out:
+ return desc;
+}
+
+struct pram_xblock_desc *lookup_xblock_desc(struct pram_sb_info *sbi,
+ unsigned long blocknr,
+ struct kmem_cache *cache,
+ int create)
+{
+ struct pram_xblock_desc *desc = NULL;
+
+ spin_lock(sbi-desc_tree_lock);
+ desc = __lookup_xblock_desc(sbi, blocknr, cache, create);
+ spin_unlock(sbi-desc_tree_lock);
+ return desc;
+}
+
+/* put_xblock_desc()
+ *
+ * Decrement the reference count and if it reaches zero and the
+ * desciptor has been marked to be free, then we free it.
+ * It returns 0 if the descriptor has been deleted and 1 otherwise.
+ */
+int put_xblock_desc(struct pram_sb_info *sbi, struct pram_xblock_desc *desc)
+{
+ int ret = 1;
+ if (!desc)
+ return ret;
+
+ if (atomic_dec_and_lock(desc-refcount, sbi-desc_tree_lock
[PATCH 14/16 v3] pramfs: memory protection
From: Marco Stornelli marco.storne...@gmail.com
Memory write protection.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/wprotect.c
linux-2.6.36/fs/pramfs/wprotect.c
--- linux-2.6.36-orig/fs/pramfs/wprotect.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/wprotect.c 2010-10-30 11:59:54.0 +0200
@@ -0,0 +1,41 @@
+/*
+ * FILE NAME fs/pramfs/wprotect.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Write protection for the filesystem pages.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/module.h
+#include linux/fs.h
+#include linux/mm.h
+#include linux/io.h
+#include pram.h
+
+void pram_writeable(void *vaddr, unsigned long size, int rw)
+{
+ int ret = 0;
+ unsigned long nrpages = size PAGE_SHIFT;
+ unsigned long addr = (unsigned long)vaddr;
+
+ /* Page aligned */
+ addr = PAGE_MASK;
+
+ if (size (PAGE_SIZE - 1))
+ nrpages++;
+
+ if (rw)
+ ret = set_memory_rw(addr, nrpages);
+ else
+ ret = set_memory_ro(addr, nrpages);
+
+ BUG_ON(ret);
+}
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 16/16 v3] pramfs: makefile and Kconfig
From: Marco Stornelli marco.storne...@gmail.com Makefile and Kconfig. Signed-off-by: Marco Stornelli marco.storne...@gmail.com --- diff -Nurp linux-2.6.36-orig/fs/Makefile linux-2.6.36/fs/Makefile --- linux-2.6.36-orig/fs/Makefile 2010-09-13 01:07:37.0 +0200 +++ linux-2.6.36/fs/Makefile2010-09-14 18:49:52.0 +0200 @@ -126,3 +126,4 @@ obj-$(CONFIG_BTRFS_FS) += btrfs/ obj-$(CONFIG_GFS2_FS) += gfs2/ obj-$(CONFIG_EXOFS_FS) += exofs/ obj-$(CONFIG_CEPH_FS) += ceph/ +obj-$(CONFIG_PRAMFS) += pramfs/ diff -Nurp linux-2.6.36-orig/fs/Kconfig linux-2.6.36/fs/Kconfig --- linux-2.6.36-orig/fs/Kconfig2010-09-13 01:07:37.0 +0200 +++ linux-2.6.36/fs/Kconfig 2010-09-14 18:49:52.0 +0200 @@ -13,7 +13,7 @@ source fs/ext4/Kconfig config FS_XIP # execute in place bool - depends on EXT2_FS_XIP + depends on EXT2_FS_XIP || PRAMFS_XIP default y source fs/jbd/Kconfig @@ -25,13 +25,14 @@ config FS_MBCACHE default y if EXT2_FS=y EXT2_FS_XATTR default y if EXT3_FS=y EXT3_FS_XATTR default y if EXT4_FS=y EXT4_FS_XATTR - default m if EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4_FS_XATTR + default y if PRAMFS=y PRAMFS_XATTR + default m if EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4_FS_XATTR || PRAMFS_XATTR source fs/reiserfs/Kconfig source fs/jfs/Kconfig config FS_POSIX_ACL -# Posix ACL utility routines (for now, only ext2/ext3/jfs/reiserfs/nfs4) +# Posix ACL utility routines (for now, only ext2/ext3/jfs/reiserfs/nfs4/pramfs) # # NOTE: you can implement Posix ACLs without these helpers (XFS does). # Never use this symbol for ifdefs. @@ -189,6 +190,7 @@ source fs/romfs/Kconfig source fs/sysv/Kconfig source fs/ufs/Kconfig source fs/exofs/Kconfig +source fs/pramfs/Kconfig endif # MISC_FILESYSTEMS diff -Nurp linux-2.6.36-orig/fs/pramfs/Kconfig linux-2.6.36/fs/pramfs/Kconfig --- linux-2.6.36-orig/fs/pramfs/Kconfig 1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/fs/pramfs/Kconfig 2010-10-30 10:30:19.0 +0200 @@ -0,0 +1,72 @@ +config PRAMFS + tristate Persistent and Protected RAM file system support + depends on HAS_IOMEM EXPERIMENTAL + select CRC16 + help + If your system has a block of fast (comparable in access speed to + system memory) and non-volatile RAM and you wish to mount a + light-weight, full-featured, and space-efficient filesystem over it, + say Y here, and read file:Documentation/filesystems/pramfs.txt. + + To compile this as a module, choose M here: the module will be + called pramfs. + +config PRAMFS_XIP + bool Enable Execute-in-place in PRAMFS + depends on PRAMFS !PRAMFS_WRITE_PROTECT + help + Say Y here to enable XIP feature of PRAMFS. + +config PRAMFS_WRITE_PROTECT + bool Enable PRAMFS write protection + depends on PRAMFS MMU HAVE_SET_MEMORY_RO + default y + help + Say Y here to enable the write protect feature of PRAMFS. + +config PRAMFS_XATTR + bool PRAMFS extended attributes + depends on PRAMFS + help + Extended attributes are name:value pairs associated with inodes by + the kernel or by users (see the attr(5) manual page, or visit + http://acl.bestbits.at/ for details). + + If unsure, say N. + +config PRAMFS_POSIX_ACL + bool PRAMFS POSIX Access Control Lists + depends on PRAMFS_XATTR + select FS_POSIX_ACL + help + Posix Access Control Lists (ACLs) support permissions for users and + groups beyond the owner/group/world scheme. + + To learn more about Access Control Lists, visit the Posix ACLs for + Linux website http://acl.bestbits.at/. + + If you don't know what Access Control Lists are, say N. + +config PRAMFS_SECURITY + bool PRAMFS Security Labels + depends on PRAMFS_XATTR + help + Security labels support alternative access control models + implemented by security modules like SELinux. This option + enables an extended attribute handler for file security + labels in the pram filesystem. + + If you are not using a security module that requires using + extended attributes for file security labels, say N. + +config PRAMFS_TEST + boolean + depends on PRAMFS + +config PRAMFS_TEST_MODULE + tristate PRAMFS Test + depends on PRAMFS m + select PRAMFS_TEST + help + Say Y here to build a simple module to test the protection of + PRAMFS. The module will be called pramfs_test. diff -Nurp linux-2.6.36-orig/fs/pramfs/Makefile linux-2.6.36/fs/pramfs/Makefile --- linux-2.6.36-orig/fs/pramfs/Makefile1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/fs/pramfs/Makefile 2010-09-14 18:49:52.0 +0200 @@ -0,0 +1,14 @@ +# +# Makefile
[PATCH 15/16 v3] pramfs: test module
From: Marco Stornelli marco.storne...@gmail.com
Test module.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/pramfs_test.c
linux-2.6.36/fs/pramfs/pramfs_test.c
--- linux-2.6.36-orig/fs/pramfs/pramfs_test.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/pramfs_test.c2010-09-14 18:49:52.0
+0200
@@ -0,0 +1,49 @@
+/*
+ * FILE NAME fs/pramfs/pramfs_test.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Pramfs test module.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/module.h
+#include linux/version.h
+#include linux/init.h
+#include linux/fs.h
+#include pram.h
+
+int __init test_pramfs_write(void)
+{
+ struct pram_super_block *psb;
+
+ psb = get_pram_super();
+ if (!psb) {
+ printk(KERN_ERR
+ %s: PRAMFS super block not found (not mounted?)\n,
+ __func__);
+ return 1;
+ }
+
+ /*
+* Attempt an unprotected clear of checksum information in the
+* superblock, this should cause a kernel page protection fault.
+*/
+ printk(%s: writing to kernel VA %p\n, __func__, psb);
+ psb-s_sum = 0;
+
+ return 0;
+}
+
+void test_pramfs_write_cleanup(void) {}
+
+/* Module information */
+MODULE_LICENSE(GPL);
+module_init(test_pramfs_write);
+module_exit(test_pramfs_write_cleanup);
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 08/16 v2] pramfs: headers
2010/11/8 Ryan Mallon r...@bluewatersys.com:
On 11/08/2010 08:49 PM, Marco Stornelli wrote:
2010/11/7 Ryan Mallon r...@bluewatersys.com:
On 11/06/2010 09:58 PM, Marco Stornelli wrote:
From: Marco Stornelli marco.storne...@gmail.com
Definitions for the PRAMFS filesystem.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/pram.h linux-2.6.36/fs/pramfs/pram.h
--- linux-2.6.36-orig/fs/pramfs/pram.h 1970-01-01
01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/pram.h 2010-10-30 12:02:45.0 +0200
@@ -0,0 +1,317 @@
+/*
+ * Structure of the super block in PRAMFS
+ */
+struct pram_super_block {
+ __be16 s_sum; /* checksum of this sb, including padding */
+ __be64 s_size; /* total size of fs in bytes */
+ __be32 s_blocksize; /* blocksize in bytes */
+ __be32 s_inodes_count; /* total inodes count (used or free) */
+ __be32 s_free_inodes_count;/* free inodes count */
+ __be32 s_free_inode_hint; /* start hint for locating free inodes */
+ __be32 s_blocks_count; /* total data blocks count (used or free) */
+ __be32 s_free_blocks_count;/* free data blocks count */
+ __be32 s_free_blocknr_hint;/* free data blocks count */
+ __be64 s_bitmap_start; /* data block in-use bitmap location */
+ __be32 s_bitmap_blocks;/* size of bitmap in number of blocks */
+ __be32 s_mtime; /* Mount time */
+ __be32 s_wtime; /* Write time */
+ __be16 s_magic; /* Magic signature */
+ char s_volume_name[16]; /* volume name */
+};
Is there a particular reason to use big endian types for the data
structures? On a little endian machine you will end up converting values
everywhere. I assume that you don't expect the machine to change
endianess between reboots :-). If this is for generating/reading
filesystems from userspace, wouldn't it be better to have the userspace
tools specify the target endianess and do the conversions there?
~Ryan
Yes, there is a reason. In the first review a comment was: the fs must
have a fix endianess layout. This fs is designed for the embedded
world mainly. Since most of cpus used in this case are big-endian, it
means that for typical use case, there is no cost for endianess
conversion.
ARM, which is a large portion of the embedded space, is typically little
endian.
Not always. Indeed, I didn't say *all* cpu used are big-endian.
Why does a filesystem need to have a specific endianess layout?
Especially for a highly specialised filesystem like this.
I didn't agree with it, but in the first review there was more than
one developer that said this thing. The main reason was to read the
format (for example with JTAG) or to create an image with a fix
format. I remember that someone said that there was a similar problem
with jffs2 and the experience tell to us that a fix endianess is
important. At that point I decided to use big-endian. You can see all
the discussion in lkml. The review has been done at June 2009.
Regards,
Marco
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 08/16 v2] pramfs: headers
2010/11/7 Ryan Mallon r...@bluewatersys.com:
On 11/06/2010 09:58 PM, Marco Stornelli wrote:
From: Marco Stornelli marco.storne...@gmail.com
Definitions for the PRAMFS filesystem.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/pram.h linux-2.6.36/fs/pramfs/pram.h
--- linux-2.6.36-orig/fs/pramfs/pram.h 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/pram.h 2010-10-30 12:02:45.0 +0200
@@ -0,0 +1,317 @@
+/*
+ * Structure of the super block in PRAMFS
+ */
+struct pram_super_block {
+ __be16 s_sum; /* checksum of this sb, including padding */
+ __be64 s_size; /* total size of fs in bytes */
+ __be32 s_blocksize; /* blocksize in bytes */
+ __be32 s_inodes_count; /* total inodes count (used or free) */
+ __be32 s_free_inodes_count;/* free inodes count */
+ __be32 s_free_inode_hint; /* start hint for locating free inodes */
+ __be32 s_blocks_count; /* total data blocks count (used or free) */
+ __be32 s_free_blocks_count;/* free data blocks count */
+ __be32 s_free_blocknr_hint;/* free data blocks count */
+ __be64 s_bitmap_start; /* data block in-use bitmap location */
+ __be32 s_bitmap_blocks;/* size of bitmap in number of blocks */
+ __be32 s_mtime; /* Mount time */
+ __be32 s_wtime; /* Write time */
+ __be16 s_magic; /* Magic signature */
+ char s_volume_name[16]; /* volume name */
+};
Is there a particular reason to use big endian types for the data
structures? On a little endian machine you will end up converting values
everywhere. I assume that you don't expect the machine to change
endianess between reboots :-). If this is for generating/reading
filesystems from userspace, wouldn't it be better to have the userspace
tools specify the target endianess and do the conversions there?
~Ryan
Yes, there is a reason. In the first review a comment was: the fs must
have a fix endianess layout. This fs is designed for the embedded
world mainly. Since most of cpus used in this case are big-endian, it
means that for typical use case, there is no cost for endianess
conversion.
Marco
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 00/16 v2] pramfs: persistent and protected RAM Filesystem
Hi all, I send the patch series again. I fix documentation problems reported by Randy Dunlap and Kieran Bingham. I reworked the memory protection functions according to the suggestions of Andi Kleen. I ask to Andrew to evaluate to insert this fs in mainline. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 01/16 v2] pramfs: documentation
From: Marco Stornelli marco.storne...@gmail.com Documentation for PRAMFS. Signed-off-by: Marco Stornelli marco.storne...@gmail.com --- diff -Nurp linux-2.6.36-orig/Documentation/filesystems/pramfs.txt linux-2.6.36/Documentation/filesystems/pramfs.txt --- linux-2.6.36-orig/Documentation/filesystems/pramfs.txt 1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/Documentation/filesystems/pramfs.txt 2010-10-23 09:04:32.0 +0200 @@ -0,0 +1,296 @@ + +PRAMFS Overview +=== + +Many embedded systems have a block of non-volatile RAM separate from +normal system memory, i.e. of which the kernel maintains no memory page +descriptors. For such systems it would be beneficial to mount a +fast read/write filesystem over this I/O memory, for storing frequently +accessed data that must survive system reboots and power cycles. An +example usage might be system logs under /var/log, or a user address +book in a cell phone or PDA. + +Linux traditionally had no support for a persistent, non-volatile RAM-based +filesystem, persistent meaning the filesystem survives a system reboot +or power cycle intact. The RAM-based filesystems such as tmpfs and ramfs +have no actual backing store but exist entirely in the page and buffer +caches, hence the filesystem disappears after a system reboot or +power cycle. + +A relatively straightforward solution is to write a simple block driver +for the non-volatile RAM, and mount over it any disk-based filesystem such +as ext2, ext3, ext4, etc. + +But the disk-based fs over non-volatile RAM block driver approach has +some drawbacks: + +1. Complexity of disk-based fs: disk-based filesystems such as ext2/ext3/ext4 + were designed for optimum performance on spinning disk media, so they + implement features such as block groups, which attempts to group inode data + into a contiguous set of data blocks to minimize disk seeking when accessing + files. For RAM there is no such concern; a file's data blocks can be + scattered throughout the media with no access speed penalty at all. So block + groups in a filesystem mounted over RAM just adds unnecessary + complexity. A better approach is to use a filesystem specifically + tailored to RAM media which does away with these disk-based features. + This increases the efficient use of space on the media, i.e. more + space is dedicated to actual file data storage and less to meta-data + needed to maintain that file data. + +2. Different problems between disks and RAM: Because PRAMFS attempts to avoid + filesystem corruption caused by kernel bugs, dirty pages in the page cache + are not allowed to be written back to the backing-store RAM. This way, an + errant write into the page cache will not get written back to the filesystem. + However, if the backing-store RAM is comparable in access speed to system + memory, the penalty of not using caching is minimal. With this consideration + it's better to move file data directly between the user buffers and the backing + store RAM, i.e. use direct I/O. This prevents the unnecessary populating of + the page cache with dirty pages. However direct I/O has to be enabled at + every file open. To enable direct I/O at all times for all regular files + requires either that applications be modified to include the O_DIRECT flag on + all file opens, or that the filesystem used performs direct I/O by default. + +The Persistent/Protected RAM Special Filesystem (PRAMFS) is a read/write +filesystem that has been designed to address these issues. PRAMFS is targeted +to fast I/O memory, and if the memory is non-volatile, the filesystem will be +persistent. + +In PRAMFS, direct I/O is enabled across all files in the filesystem, in other +words the O_DIRECT flag is forced on every open of a PRAMFS file. Also, file +I/O in the PRAMFS is always synchronous. There is no need to block the current +process while the transfer to/from the PRAMFS is in progress, since one of +the requirements of the PRAMFS is that the filesystem exists in fast RAM. So +file I/O in PRAMFS is always direct, synchronous, and never blocks. + +The data organization in PRAMFS can be thought of as an extremely simplified +version of ext2, such that the ratio of data to meta-data is very high. + +PRAMFS supports the execute-in-place. With XIP, instead of keeping data in the +page cache, the need to have a page cache copy is eliminated completely. +Readwrite type operations are performed directly from/to the memory. For file +mappings, the RAM itself is mapped directly into userspace. XIP, in addition, +speed up the applications start-up time because it removes the needs of any +copies. + +PRAMFS is write protected. The page table entries that map the backing-store +RAM are normally marked read-only. Write operations into the filesystem +temporarily mark the affected pages as writeable, the write operation is +carried out with locks held, and then the page table entries is +marked read-only
[PATCH 02/16 v2] pramfs: super block operations
From: Marco Stornelli marco.storne...@gmail.com
Super block operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/super.c linux-2.6.36/fs/pramfs/super.c
--- linux-2.6.36-orig/fs/pramfs/super.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/super.c 2010-09-25 14:09:47.0 +0200
@@ -0,0 +1,740 @@
+/*
+ * FILE NAME fs/pramfs/super.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Super block operations.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/module.h
+#include linux/string.h
+#include linux/slab.h
+#include linux/init.h
+#include linux/blkdev.h
+#include linux/parser.h
+#include linux/vfs.h
+#include linux/uaccess.h
+#include linux/io.h
+#include linux/seq_file.h
+#include linux/mount.h
+#include linux/mm.h
+#include linux/ctype.h
+#include linux/bitops.h
+#include linux/magic.h
+#include linux/exportfs.h
+#include linux/random.h
+#include xattr.h
+#include pram.h
+
+static struct super_operations pram_sops;
+static const struct export_operations pram_export_ops;
+static struct kmem_cache *pram_inode_cachep;
+
+#ifdef CONFIG_PRAMFS_TEST
+static void *first_pram_super;
+
+struct pram_super_block *get_pram_super(void)
+{
+ return (struct pram_super_block *)first_pram_super;
+}
+EXPORT_SYMBOL(get_pram_super);
+#endif
+
+static void pram_set_blocksize(struct super_block *sb, unsigned long size)
+{
+ int bits;
+
+ /*
+ * We've already validated the user input and the value here must be
+ * between PRAM_MAX_BLOCK_SIZE and PRAM_MIN_BLOCK_SIZE
+ * and it must be a power of 2.
+ */
+ bits = fls(size) - 1;
+ sb-s_blocksize_bits = bits;
+ sb-s_blocksize = (1bits);
+}
+
+static inline void *pram_ioremap(phys_addr_t phys_addr, ssize_t size)
+{
+ void *retval;
+
+ /*
+* NOTE: Userland may not map this resource, we will mark the region so
+* /dev/mem and the sysfs MMIO access will not be allowed. This
+* restriction depends on STRICT_DEVMEM option. If this option is
+* disabled or not available we mark the region only as busy.
+*/
+ retval = request_mem_region_exclusive(phys_addr, size, pramfs);
+ if (!retval)
+ goto fail;
+
+ retval = ioremap_nocache(phys_addr, size);
+
+ if (retval)
+ wrprotect(retval, size);
+fail:
+ return retval;
+}
+
+static loff_t pram_max_size(int bits)
+{
+ loff_t res;
+ res = (1ULL (3*bits - 6)) - 1;
+
+ if (res MAX_LFS_FILESIZE)
+ res = MAX_LFS_FILESIZE;
+
+ pram_info(Max file size %llu bytes, res);
+ return res;
+}
+
+enum {
+ Opt_addr, Opt_bpi, Opt_size,
+ Opt_num_inodes, Opt_mode, Opt_uid,
+ Opt_gid, Opt_blocksize, Opt_err
+};
+
+static const match_table_t tokens = {
+ {Opt_bpi, physaddr=%x},
+ {Opt_bpi, bpi=%u},
+ {Opt_size, init=%s},
+ {Opt_num_inodes, N=%u},
+ {Opt_mode, mode=%o},
+ {Opt_uid, uid=%u},
+ {Opt_gid, gid=%u},
+ {Opt_blocksize, bs=%s},
+ {Opt_err, NULL},
+};
+
+static phys_addr_t get_phys_addr(void **data)
+{
+ phys_addr_t phys_addr;
+ char *options = (char *) *data;
+
+ if (!options || strncmp(options, physaddr=, 9) != 0)
+ return (phys_addr_t)ULLONG_MAX;
+ options += 9;
+ phys_addr = (phys_addr_t)simple_strtoull(options, options, 0);
+ if (*options *options != ',') {
+ pram_err(Invalid phys addr specification: %s\n,
+ (char *) *data);
+ return (phys_addr_t)ULLONG_MAX;
+ }
+ if (phys_addr (PAGE_SIZE - 1)) {
+ pram_err(physical address 0x%16llx for pramfs isn't
+ aligned to a page boundary\n,
+ (u64)phys_addr);
+ return (phys_addr_t)ULLONG_MAX;
+ }
+ if (*options == ',')
+ options++;
+ *data = (void *) options;
+ return phys_addr;
+}
+
+static int pram_parse_options(char *options, struct pram_sb_info *sbi)
+{
+ char *p, *rest;
+ substring_t args[MAX_OPT_ARGS];
+ int option;
+
+ if (!options)
+ return 0;
+
+ while ((p = strsep(options, ,)) != NULL) {
+ int token;
+ if (!*p)
+ continue;
+
+ token = match_token(p, tokens, args);
+ switch (token) {
+ case Opt_addr: {
+ /* physaddr managed
[PATCH 03/16 v2] pramfs: inode operations
From: Marco Stornelli marco.storne...@gmail.com
Inode methods (allocate/free/read/write).
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/inode.c linux-2.6.36/fs/pramfs/inode.c
--- linux-2.6.36-orig/fs/pramfs/inode.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/inode.c 2010-09-26 18:04:38.0 +0200
@@ -0,0 +1,710 @@
+/*
+ * FILE NAME fs/pramfs/inode.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Inode methods (allocate/free/read/write).
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/smp_lock.h
+#include linux/sched.h
+#include linux/highuid.h
+#include linux/quotaops.h
+#include linux/module.h
+#include linux/mpage.h
+#include linux/backing-dev.h
+#include pram.h
+#include xattr.h
+#include xip.h
+#include acl.h
+
+struct backing_dev_info pram_backing_dev_info __read_mostly = {
+ .ra_pages = 0,/* No readahead */
+ .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK,
+};
+
+/*
+ * allocate a data block for inode and return it's absolute blocknr.
+ * Zeroes out the block if zero set. Increments inode-i_blocks.
+ */
+static int pram_new_data_block(struct inode *inode, unsigned long *blocknr,
int zero)
+{
+ int errval = pram_new_block(inode-i_sb, blocknr, zero);
+
+ if (!errval) {
+ struct pram_inode *pi = pram_get_inode(inode-i_sb,
+ inode-i_ino);
+ inode-i_blocks++;
+ pram_memunlock_inode(pi);
+ pi-i_blocks = cpu_to_be32(inode-i_blocks);
+ pram_memlock_inode(pi);
+ }
+
+ return errval;
+}
+
+/*
+ * find the offset to the block represented by the given inode's file
+ * relative block number.
+ */
+u64 pram_find_data_block(struct inode *inode, int file_blocknr)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *pi;
+ u64 *row; /* ptr to row block */
+ u64 *col; /* ptr to column blocks */
+ u64 bp = 0;
+ int i_row, i_col;
+ int N = sb-s_blocksize 3; /* num block ptrs per block */
+ int Nbits = sb-s_blocksize_bits - 3;
+
+ pi = pram_get_inode(sb, inode-i_ino);
+
+ i_row = file_blocknr Nbits;
+ i_col = file_blocknr (N-1);
+
+ row = pram_get_block(sb, be64_to_cpu(pi-i_type.reg.row_block));
+ if (row) {
+ col = pram_get_block(sb, be64_to_cpu(row[i_row]));
+ if (col)
+ bp = be64_to_cpu(col[i_col]);
+ }
+
+ return bp;
+}
+
+/*
+ * Free data blocks from inode in the range start = end
+ */
+static void __pram_truncate_blocks(struct inode *inode, loff_t start, loff_t
end)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *pi = pram_get_inode(sb, inode-i_ino);
+ int N = sb-s_blocksize 3; /* num block ptrs per block */
+ int Nbits = sb-s_blocksize_bits - 3;
+ int first_row_index, last_row_index, i, j;
+ unsigned long blocknr, first_blocknr, last_blocknr;
+ unsigned int freed = 0;
+ u64 *row; /* ptr to row block */
+ u64 *col; /* ptr to column blocks */
+
+ if (start end || !inode-i_blocks || !pi-i_type.reg.row_block)
+ return;
+
+ mutex_lock(PRAM_I(inode)-truncate_mutex);
+
+ first_blocknr = (start + sb-s_blocksize - 1) sb-s_blocksize_bits;
+ last_blocknr = (end + sb-s_blocksize - 1) sb-s_blocksize_bits;
+ first_row_index = first_blocknr Nbits;
+ last_row_index = last_blocknr Nbits;
+
+ row = pram_get_block(sb, be64_to_cpu(pi-i_type.reg.row_block));
+
+ for (i = first_row_index; i = last_row_index; i++) {
+ int first_col_index = (i == first_row_index) ?
+ first_blocknr (N-1) : 0;
+ int last_col_index = (i == last_row_index) ?
+ last_blocknr (N-1) : N-1;
+
+ if (unlikely(!row[i]))
+ continue;
+
+ col = pram_get_block(sb, be64_to_cpu(row[i]));
+
+ for (j = first_col_index; j = last_col_index; j++) {
+
+ if (unlikely(!col[j]))
+ continue;
+
+ blocknr = pram_get_blocknr(sb, be64_to_cpu(col[j]));
+ pram_free_block(sb, blocknr);
+ freed++;
+ pram_memunlock_block(sb, col);
+ col[j] = 0;
+ pram_memlock_block(sb, col);
+ }
+
+ if (first_col_index == 0
[PATCH 04/16 v2] pramfs: file operations
From: Marco Stornelli marco.storne...@gmail.com
File operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/file.c linux-2.6.36/fs/pramfs/file.c
--- linux-2.6.36-orig/fs/pramfs/file.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/file.c 2010-09-24 18:34:03.0 +0200
@@ -0,0 +1,166 @@
+/*
+ * FILE NAME fs/pramfs/file.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * File operations for files.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/fs.h
+#include linux/sched.h
+#include linux/slab.h
+#include linux/uio.h
+#include linux/mm.h
+#include linux/uaccess.h
+#include pram.h
+#include acl.h
+#include xip.h
+#include xattr.h
+
+static int pram_open_file(struct inode *inode, struct file *filp)
+{
+#ifndef CONFIG_PRAMFS_XIP
+ /* Without XIP we force to use Direct IO */
+ filp-f_flags |= O_DIRECT;
+#endif
+ return generic_file_open(inode, filp);
+}
+
+ssize_t __pram_direct_IO(int rw, struct kiocb *iocb,
+ const struct iovec *iov,
+ loff_t offset, unsigned long nr_segs)
+{
+ struct file *file = iocb-ki_filp;
+ struct inode *inode = file-f_mapping-host;
+ struct super_block *sb = inode-i_sb;
+ int progress = 0, hole = 0;
+ ssize_t retval = 0;
+ void *tmp = NULL;
+ unsigned long blocknr, blockoff;
+ int num_blocks, blocksize_mask, blocksize, blocksize_bits;
+ char __user *buf = iov-iov_base;
+ size_t length = iov_length(iov, nr_segs);
+
+ if (length 0)
+ return -EINVAL;
+ if ((rw == READ) (offset + length inode-i_size))
+ length = inode-i_size - offset;
+ if (!length)
+ goto out;
+
+ blocksize_bits = inode-i_sb-s_blocksize_bits;
+ blocksize = 1 blocksize_bits;
+ blocksize_mask = blocksize - 1;
+
+ /* find starting block number to access */
+ blocknr = offset blocksize_bits;
+ /* find starting offset within starting block */
+ blockoff = offset blocksize_mask;
+ /* find number of blocks to access */
+ num_blocks = (blockoff + length + blocksize_mask) blocksize_bits;
+
+ if (rw == WRITE) {
+ /* prepare a temporary buffer to hold a user data block
+ for writing. */
+ tmp = kmalloc(blocksize, GFP_KERNEL);
+ if (!tmp)
+ return -ENOMEM;
+ /* now allocate the data blocks we'll need */
+ retval = pram_alloc_blocks(inode, blocknr, num_blocks);
+ if (retval)
+ goto fail1;
+ }
+
+ while (length) {
+ int count;
+ u8 *bp = NULL;
+ u64 block = pram_find_data_block(inode, blocknr++);
+ if (unlikely(!block rw == READ)) {
+ /* We are falling in a hole */
+ hole = 1;
+ } else {
+ bp = (u8 *)pram_get_block(sb, block);
+ if (!bp)
+ goto fail2;
+ }
+
+ count = blockoff + length blocksize ?
+ blocksize - blockoff : length;
+
+ if (rw == READ) {
+ if (unlikely(hole)) {
+ retval = clear_user(buf, count);
+ if (retval) {
+ retval = -EFAULT;
+ goto fail1;
+ }
+ } else {
+ retval = copy_to_user(buf, bp[blockoff],
count);
+ if (retval) {
+ retval = -EFAULT;
+ goto fail1;
+ }
+ }
+ } else {
+ retval = copy_from_user(tmp, buf, count);
+ if (retval) {
+ retval = -EFAULT;
+ goto fail1;
+ }
+
+ pram_memunlock_block(inode-i_sb, bp);
+ memcpy(bp[blockoff], tmp, count);
+ pram_memlock_block(inode-i_sb, bp);
+ }
+
+ progress += count;
+ buf += count;
+ length -= count;
+ blockoff = 0;
+ hole = 0;
+ }
+
+fail2:
+ retval = progress;
+fail1:
+ kfree(tmp);
+out
[PATCH 05/16 v2] pramfs: block allocation
From: Marco Stornelli marco.storne...@gmail.com
Block allocation operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/balloc.c linux-2.6.36/fs/pramfs/balloc.c
--- linux-2.6.36-orig/fs/pramfs/balloc.c1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/balloc.c 2010-09-26 18:05:06.0 +0200
@@ -0,0 +1,155 @@
+/*
+ * FILE NAME fs/pramfs/balloc.c
+ *
+ * BRIEF MODULE DESCRIPTION
+ *
+ * The blocks allocation and deallocation routines.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/bitops.h
+#include pram.h
+
+/*
+ * This just marks in-use the blocks that make up the bitmap.
+ * The bitmap must be writeable before calling.
+ */
+void pram_init_bitmap(struct super_block *sb)
+{
+ struct pram_super_block *ps = pram_get_super(sb);
+ u64 *bitmap = pram_get_bitmap(sb);
+ int blocks = be32_to_cpu(ps-s_bitmap_blocks);
+
+ memset(bitmap, 0, blocks sb-s_blocksize_bits);
+
+ while (blocks = 64) {
+ *bitmap++ = (u64)ULLONG_MAX;
+ blocks -= 64;
+ }
+
+ if (blocks)
+ *bitmap = cpu_to_le64((1ULL blocks) - 1);
+}
+
+
+/* Free absolute blocknr */
+void pram_free_block(struct super_block *sb, unsigned long blocknr)
+{
+ struct pram_super_block *ps;
+ u64 bitmap_block;
+ unsigned long bitmap_bnr;
+ void *bitmap;
+ void *bp;
+
+ lock_super(sb);
+
+ bitmap = pram_get_bitmap(sb);
+ /*
+* find the block within the bitmap that contains the inuse bit
+* for the block we need to free. We need to unlock this bitmap
+* block to clear the inuse bit.
+*/
+ bitmap_bnr = blocknr (3 + sb-s_blocksize_bits);
+ bitmap_block = pram_get_block_off(sb, bitmap_bnr);
+ bp = pram_get_block(sb, bitmap_block);
+
+ pram_memunlock_block(sb, bp);
+ pram_clear_bit(blocknr, bitmap); /* mark the block free */
+ pram_memlock_block(sb, bp);
+
+ ps = pram_get_super(sb);
+ pram_memunlock_super(ps);
+ if (blocknr be32_to_cpu(ps-s_free_blocknr_hint))
+ ps-s_free_blocknr_hint = cpu_to_be32(blocknr);
+ be32_add_cpu(ps-s_free_blocks_count, 1);
+ pram_memlock_super(ps);
+
+ unlock_super(sb);
+}
+
+
+/*
+ * allocate a block and return it's absolute blocknr. Zeroes out the
+ * block if zero set.
+ */
+int pram_new_block(struct super_block *sb, unsigned long *blocknr, int zero)
+{
+ struct pram_super_block *ps;
+ off_t bitmap_block;
+ unsigned long bnr, bitmap_bnr;
+ int errval;
+ void *bitmap;
+ void *bp;
+
+ lock_super(sb);
+ ps = pram_get_super(sb);
+ bitmap = pram_get_bitmap(sb);
+
+ if (ps-s_free_blocks_count) {
+ /* find the oldest unused block */
+ bnr = pram_find_next_zero_bit(bitmap,
+be32_to_cpu(ps-s_blocks_count),
+be32_to_cpu(ps-s_free_blocknr_hint));
+
+ if (bnr be32_to_cpu(ps-s_bitmap_blocks) ||
+ bnr = be32_to_cpu(ps-s_blocks_count)) {
+ pram_err(no free blocks found!\n);
+ errval = -ENOSPC;
+ goto fail;
+ }
+
+ pram_dbg(allocating blocknr %lu\n, bnr);
+ pram_memunlock_super(ps);
+ be32_add_cpu(ps-s_free_blocks_count, -1);
+ if (bnr (be32_to_cpu(ps-s_blocks_count)-1))
+ ps-s_free_blocknr_hint = cpu_to_be32(bnr+1);
+ else
+ ps-s_free_blocknr_hint = 0;
+ pram_memlock_super(ps);
+ } else {
+ pram_err(all blocks allocated\n);
+ errval = -ENOSPC;
+ goto fail;
+ }
+
+ /*
+* find the block within the bitmap that contains the inuse bit
+* for the unused block we just found. We need to unlock it to
+* set the inuse bit.
+*/
+ bitmap_bnr = bnr (3 + sb-s_blocksize_bits);
+ bitmap_block = pram_get_block_off(sb, bitmap_bnr);
+ bp = pram_get_block(sb, bitmap_block);
+
+ pram_memunlock_block(sb, bp);
+ pram_set_bit(bnr, bitmap); /* mark the new block in use */
+ pram_memlock_block(sb, bp);
+
+ if (zero) {
+ bp = pram_get_block(sb, pram_get_block_off(sb, bnr));
+ pram_memunlock_block(sb, bp);
+ memset(bp, 0, sb-s_blocksize
[PATCH 07/16 v2] pramfs: symbolic links
From: Marco Stornelli marco.storne...@gmail.com
Symlink operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/symlink.c
linux-2.6.36/fs/pramfs/symlink.c
--- linux-2.6.36-orig/fs/pramfs/symlink.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/symlink.c2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,78 @@
+/*
+ * FILE NAME fs/pramfs/symlink.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Symlink operations
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include pram.h
+#include xattr.h
+
+int pram_block_symlink(struct inode *inode, const char *symname, int len)
+{
+ struct super_block *sb = inode-i_sb;
+ u64 block;
+ char *blockp;
+ int err;
+
+ err = pram_alloc_blocks(inode, 0, 1);
+ if (err)
+ return err;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+
+ pram_memunlock_block(sb, blockp);
+ memcpy(blockp, symname, len);
+ blockp[len] = '\0';
+ pram_memlock_block(sb, blockp);
+ return 0;
+}
+
+static int pram_readlink(struct dentry *dentry, char *buffer, int buflen)
+{
+ struct inode *inode = dentry-d_inode;
+ struct super_block *sb = inode-i_sb;
+ u64 block;
+ char *blockp;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+ return vfs_readlink(dentry, buffer, buflen, blockp);
+}
+
+static void *pram_follow_link(struct dentry *dentry, struct nameidata *nd)
+{
+ struct inode *inode = dentry-d_inode;
+ struct super_block *sb = inode-i_sb;
+ off_t block;
+ int status;
+ char *blockp;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+ status = vfs_follow_link(nd, blockp);
+ return ERR_PTR(status);
+}
+
+struct inode_operations pram_symlink_inode_operations = {
+ .readlink = pram_readlink,
+ .follow_link= pram_follow_link,
+ .setattr= pram_notify_change,
+#ifdef CONFIG_PRAMFS_XATTR
+ .setxattr = generic_setxattr,
+ .getxattr = generic_getxattr,
+ .listxattr = pram_listxattr,
+ .removexattr= generic_removexattr,
+#endif
+};
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 08/16 v2] pramfs: headers
From: Marco Stornelli marco.storne...@gmail.com
Definitions for the PRAMFS filesystem.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/pram.h linux-2.6.36/fs/pramfs/pram.h
--- linux-2.6.36-orig/fs/pramfs/pram.h 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/pram.h 2010-10-30 12:02:45.0 +0200
@@ -0,0 +1,317 @@
+/*
+ * FILE NAME pram.h
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Definitions for the PRAMFS filesystem.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#ifndef __PRAM_H
+#define __PRAM_H
+
+#include linux/buffer_head.h
+#include linux/pram_fs.h
+#include linux/pram_fs_sb.h
+#include linux/crc16.h
+#include linux/mutex.h
+#include linux/types.h
+
+/*
+ * Debug code
+ */
+#define pram_dbg(s, args...) pr_debug(PRAMFS: s, ## args)
+#define pram_err(s, args...) pr_err(PRAMFS: s, ## args)
+#define pram_warn(s, args...) pr_warning(PRAMFS: s, ## args)
+#define pram_info(s, args...) pr_info(PRAMFS: s, ## args)
+
+/* Function Prototypes */
+
+#ifdef CONFIG_PRAMFS_XIP
+
+#define pram_read xip_file_read
+#define pram_write xip_file_write
+#define pram_mmap xip_file_mmap
+#define pram_aio_read NULL
+#define pram_aio_write NULL
+#define pram_readpage NULL
+#define pram_direct_IO NULL
+
+#else
+
+#define pram_read do_sync_read
+#define pram_write do_sync_write
+#define pram_mmap __pram_mmap
+#define pram_aio_read generic_file_aio_read
+#define pram_aio_write generic_file_aio_write
+#define pram_direct_IO __pram_direct_IO
+#define pram_readpage __pram_readpage
+
+extern int pram_get_and_update_block(struct inode *inode, sector_t iblock,
+struct buffer_head *bh, int create);
+
+static inline int __pram_readpage(struct file *file, struct page *page)
+{
+ return block_read_full_page(page, pram_get_and_update_block);
+}
+
+/* file.c */
+extern ssize_t __pram_direct_IO(int rw, struct kiocb *iocb,
+ const struct iovec *iov,
+ loff_t offset, unsigned long nr_segs);
+
+
+#endif /* CONFIG_PRAMFS_XIP */
+
+#define pram_set_bit ext2_set_bit
+#define pram_clear_bit ext2_clear_bit
+#define pram_find_next_zero_bitext2_find_next_zero_bit
+
+/* balloc.c */
+extern void pram_init_bitmap(struct super_block *sb);
+extern void pram_free_block(struct super_block *sb, unsigned long blocknr);
+extern int pram_new_block(struct super_block *sb, unsigned long *blocknr, int
zero);
+extern unsigned long pram_count_free_blocks(struct super_block *sb);
+
+/* dir.c */
+extern int pram_add_link(struct dentry *dentry, struct inode *inode);
+extern int pram_remove_link(struct inode *inode);
+
+/* namei.c */
+extern struct dentry *pram_get_parent(struct dentry *child);
+
+/* inode.c */
+extern int pram_alloc_blocks(struct inode *inode, int file_blocknr, int num);
+extern u64 pram_find_data_block(struct inode *inode,
+int file_blocknr);
+
+extern struct inode *pram_iget(struct super_block *sb, unsigned long ino);
+extern void pram_put_inode(struct inode *inode);
+extern void pram_evict_inode(struct inode *inode);
+extern struct inode *pram_new_inode(struct inode *dir, int mode);
+extern int pram_update_inode(struct inode *inode);
+extern int pram_write_inode(struct inode *inode, struct writeback_control
*wbc);
+extern void pram_dirty_inode(struct inode *inode);
+extern int pram_notify_change(struct dentry *dentry, struct iattr *attr);
+
+
+/* super.c */
+#ifdef CONFIG_PRAMFS_TEST
+extern struct pram_super_block *get_pram_super(void);
+#endif
+extern struct super_block *pram_read_super(struct super_block *sb,
+ void *data,
+ int silent);
+extern int pram_statfs(struct dentry *d, struct kstatfs *buf);
+extern int pram_remount(struct super_block *sb, int *flags, char *data);
+
+/* symlink.c */
+extern int pram_block_symlink(struct inode *inode,
+ const char *symname, int len);
+
+
+#ifdef CONFIG_PRAMFS_WRITE_PROTECT
+extern void pram_writeable(void *vaddr, unsigned long size, int rw);
+
+#define wrprotect(addr, size) pram_writeable(addr, size, 0)
+
+#else
+
+#define wrprotect(addr, size) do {} while (0)
+
+#endif /* CONFIG PRAMFS_WRITE_PROTECT */
+
+/* Inline functions start here */
+
+static inline int pram_calc_checksum(u8 *data, int n)
+{
+ u16 crc = 0;
+ crc = crc16(~0, (__u8 *)data + sizeof(__be16), n - sizeof(__be16));
+ if (*((__be16 *)data
[PATCH 09/16 v2] pramfs: dir operations
From: Marco Stornelli marco.storne...@gmail.com
File operations for directories.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/dir.c linux-2.6.36/fs/pramfs/dir.c
--- linux-2.6.36-orig/fs/pramfs/dir.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/dir.c2010-09-17 19:08:54.0 +0200
@@ -0,0 +1,215 @@
+/*
+ * FILE NAME fs/pramfs/dir.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * File operations for directories.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/pagemap.h
+#include pram.h
+
+/*
+ * Parent is locked.
+ */
+int pram_add_link(struct dentry *dentry, struct inode *inode)
+{
+ struct inode *dir = dentry-d_parent-d_inode;
+ struct pram_inode *pidir, *pi, *pitail = NULL;
+ u64 tail_ino, prev_ino;
+
+ const char *name = dentry-d_name.name;
+
+ int namelen = dentry-d_name.len PRAM_NAME_LEN ?
+ PRAM_NAME_LEN : dentry-d_name.len;
+
+ pidir = pram_get_inode(dir-i_sb, dir-i_ino);
+ pi = pram_get_inode(dir-i_sb, inode-i_ino);
+
+ dir-i_mtime = dir-i_ctime = CURRENT_TIME;
+
+ tail_ino = be64_to_cpu(pidir-i_type.dir.tail);
+ if (tail_ino != 0) {
+ pitail = pram_get_inode(dir-i_sb, tail_ino);
+ pram_memunlock_inode(pitail);
+ pitail-i_d.d_next = cpu_to_be64(inode-i_ino);
+ pram_memlock_inode(pitail);
+
+ prev_ino = tail_ino;
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = cpu_to_be64(inode-i_ino);
+ pidir-i_mtime = cpu_to_be32(dir-i_mtime.tv_sec);
+ pidir-i_ctime = cpu_to_be32(dir-i_ctime.tv_sec);
+ pram_memlock_inode(pidir);
+ } else {
+ /* the directory is empty */
+ prev_ino = 0;
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = cpu_to_be64(inode-i_ino);
+ pidir-i_type.dir.head = cpu_to_be64(inode-i_ino);
+ pidir-i_mtime = cpu_to_be32(dir-i_mtime.tv_sec);
+ pidir-i_ctime = cpu_to_be32(dir-i_ctime.tv_sec);
+ pram_memlock_inode(pidir);
+ }
+
+
+ pram_memunlock_inode(pi);
+ pi-i_d.d_prev = cpu_to_be64(prev_ino);
+ pi-i_d.d_parent = cpu_to_be64(dir-i_ino);
+ memcpy(pi-i_d.d_name, name, namelen);
+ pi-i_d.d_name[namelen] = '\0';
+ pram_memlock_inode(pi);
+ return 0;
+}
+
+int pram_remove_link(struct inode *inode)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *prev = NULL;
+ struct pram_inode *next = NULL;
+ struct pram_inode *pidir, *pi;
+
+ pi = pram_get_inode(sb, inode-i_ino);
+ pidir = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_parent));
+ if (!pidir)
+ return -EACCES;
+
+ if (inode-i_ino == be64_to_cpu(pidir-i_type.dir.head)) {
+ /* first inode in directory */
+ next = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_next));
+
+ if (next) {
+ pram_memunlock_inode(next);
+ next-i_d.d_prev = 0;
+ pram_memlock_inode(next);
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.head = pi-i_d.d_next;
+ } else {
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.head = 0;
+ pidir-i_type.dir.tail = 0;
+ }
+ pram_memlock_inode(pidir);
+ } else if (inode-i_ino == be64_to_cpu(pidir-i_type.dir.tail)) {
+ /* last inode in directory */
+ prev = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_prev));
+
+ pram_memunlock_inode(prev);
+ prev-i_d.d_next = 0;
+ pram_memlock_inode(prev);
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = pi-i_d.d_prev;
+ pram_memlock_inode(pidir);
+ } else {
+ /* somewhere in the middle */
+ prev = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_prev));
+ next = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_next));
+
+ if (prev next) {
+ pram_memunlock_inode(prev);
+ prev-i_d.d_next = pi-i_d.d_next;
+ pram_memlock_inode(prev);
+
+ pram_memunlock_inode(next);
+ next-i_d.d_prev = pi-i_d.d_prev
[PATCH 10/16 v2] pramfs: XIP operations
From: Marco Stornelli marco.storne...@gmail.com
XIP operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/xip.c linux-2.6.36/fs/pramfs/xip.c
--- linux-2.6.36-orig/fs/pramfs/xip.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/xip.c2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,90 @@
+/*
+ * FILE NAME fs/pramfs/xip.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * XIP operations.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/mm.h
+#include linux/fs.h
+#include linux/genhd.h
+#include linux/buffer_head.h
+#include pram.h
+#include xip.h
+
+static int pram_find_and_alloc_blocks(struct inode *inode, sector_t iblock,
+sector_t *data_block, int create)
+{
+ int err = -EIO;
+ u64 block;
+
+ mutex_lock(PRAM_I(inode)-truncate_lock);
+
+ block = pram_find_data_block(inode, iblock);
+
+ if (!block) {
+ if (!create) {
+ err = -ENODATA;
+ goto err;
+ }
+
+ err = pram_alloc_blocks(inode, iblock, 1);
+ if (err)
+ goto err;
+
+ block = pram_find_data_block(inode, iblock);
+ if (!block) {
+ err = -ENODATA;
+ goto err;
+ }
+ }
+
+ *data_block = block;
+ err = 0;
+
+ err:
+ mutex_unlock(PRAM_I(inode)-truncate_lock);
+ return err;
+}
+
+
+static int __pram_get_block(struct inode *inode, pgoff_t pgoff, int create,
+ sector_t *result)
+{
+ int rc = 0;
+ sector_t iblock;
+
+ /* find starting block number to access */
+ iblock = (sector_t)pgoff (PAGE_CACHE_SHIFT - inode-i_blkbits);
+
+ rc = pram_find_and_alloc_blocks(inode, iblock, result, create);
+
+ if (rc == -ENODATA)
+ BUG_ON(create);
+
+ return rc;
+}
+
+int pram_get_xip_mem(struct address_space *mapping, pgoff_t pgoff, int create,
+ void **kmem, unsigned long *pfn)
+{
+ int rc;
+ sector_t block;
+
+ /* first, retrieve the block */
+ rc = __pram_get_block(mapping-host, pgoff, create, block);
+ if (rc)
+ goto exit;
+
+ *kmem = pram_get_block(mapping-host-i_sb, block);
+ *pfn = page_to_pfn(virt_to_page((unsigned long)*kmem));
+
+exit:
+ return rc;
+}
diff -Nurp linux-2.6.36-orig/fs/pramfs/xip.h linux-2.6.36/fs/pramfs/xip.h
--- linux-2.6.36-orig/fs/pramfs/xip.h 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/xip.h2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,24 @@
+/*
+ * FILE NAME fs/pramfs/xip.h
+ *
+ * BRIEF DESCRIPTION
+ *
+ * XIP operations.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifdef CONFIG_PRAMFS_XIP
+
+int pram_get_xip_mem(struct address_space *, pgoff_t, int, void **,
+ unsigned long *);
+
+#else
+
+#define pram_get_xip_mem NULL
+
+#endif
+
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 11/16 v2] pramfs: ACL management
From: Marco Stornelli marco.storne...@gmail.com
ACL operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/acl.c linux-2.6.36/fs/pramfs/acl.c
--- linux-2.6.36-orig/fs/pramfs/acl.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/acl.c2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,418 @@
+/*
+ * FILE NAME fs/pramfs/acl.c
+ *
+ * BRIEF MODULE DESCRIPTION
+ *
+ * POSIX ACL operations
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * based on fs/ext2/acl.c with the following copyright:
+ *
+ * Copyright (C) 2001-2003 Andreas Gruenbacher, agr...@suse.de
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/capability.h
+#include linux/init.h
+#include linux/sched.h
+#include linux/slab.h
+#include linux/fs.h
+#include pram.h
+#include xattr.h
+#include acl.h
+
+/*
+ * Load ACL information from filesystem.
+ */
+static struct posix_acl *pram_acl_load(const void *value, size_t size)
+{
+ const char *end = (char *)value + size;
+ int n, count;
+ struct posix_acl *acl;
+
+ if (!value)
+ return NULL;
+ if (size sizeof(struct pram_acl_header))
+return ERR_PTR(-EINVAL);
+ if (((struct pram_acl_header *)value)-a_version !=
+ cpu_to_be32(PRAM_ACL_VERSION))
+ return ERR_PTR(-EINVAL);
+ value = (char *)value + sizeof(struct pram_acl_header);
+ count = pram_acl_count(size);
+ if (count 0)
+ return ERR_PTR(-EINVAL);
+ if (count == 0)
+ return NULL;
+ acl = posix_acl_alloc(count, GFP_KERNEL);
+ if (!acl)
+ return ERR_PTR(-ENOMEM);
+ for (n = 0; n count; n++) {
+ struct pram_acl_entry *entry = (struct pram_acl_entry *)value;
+ if ((char *)value + sizeof(struct pram_acl_entry_short) end)
+ goto fail;
+ acl-a_entries[n].e_tag = be16_to_cpu(entry-e_tag);
+ acl-a_entries[n].e_perm = be16_to_cpu(entry-e_perm);
+ switch (acl-a_entries[n].e_tag) {
+ case ACL_USER_OBJ:
+ case ACL_GROUP_OBJ:
+ case ACL_MASK:
+ case ACL_OTHER:
+ value = (char *)value +
+ sizeof(struct pram_acl_entry_short);
+ acl-a_entries[n].e_id = ACL_UNDEFINED_ID;
+ break;
+ case ACL_USER:
+ case ACL_GROUP:
+ value = (char *)value + sizeof(struct pram_acl_entry);
+ if ((char *)value end)
+ goto fail;
+ acl-a_entries[n].e_id =
+ be32_to_cpu(entry-e_id);
+ break;
+ default:
+ goto fail;
+ }
+ }
+ if (value != end)
+ goto fail;
+ return acl;
+
+fail:
+ posix_acl_release(acl);
+ return ERR_PTR(-EINVAL);
+}
+
+/*
+ * Save ACL information into the filesystem.
+ */
+static void *pram_acl_save(const struct posix_acl *acl, size_t *size)
+{
+ struct pram_acl_header *ext_acl;
+ char *e;
+ size_t n;
+
+ *size = pram_acl_size(acl-a_count);
+ ext_acl = kmalloc(sizeof(struct pram_acl_header) + acl-a_count *
+ sizeof(struct pram_acl_entry), GFP_KERNEL);
+ if (!ext_acl)
+ return ERR_PTR(-ENOMEM);
+ ext_acl-a_version = cpu_to_be32(PRAM_ACL_VERSION);
+ e = (char *)ext_acl + sizeof(struct pram_acl_header);
+ for (n = 0; n acl-a_count; n++) {
+ struct pram_acl_entry *entry = (struct pram_acl_entry *)e;
+ entry-e_tag = cpu_to_be16(acl-a_entries[n].e_tag);
+ entry-e_perm = cpu_to_be16(acl-a_entries[n].e_perm);
+ switch (acl-a_entries[n].e_tag) {
+ case ACL_USER:
+ case ACL_GROUP:
+ entry-e_id =
+ cpu_to_be32(acl-a_entries[n].e_id);
+ e += sizeof(struct pram_acl_entry);
+ break;
+ case ACL_USER_OBJ:
+ case ACL_GROUP_OBJ:
+ case ACL_MASK:
+ case ACL_OTHER:
+ e += sizeof(struct pram_acl_entry_short);
+ break;
+ default:
+ goto fail;
+ }
+ }
+ return (char *)ext_acl;
+
+fail:
+ kfree(ext_acl);
+ return ERR_PTR(-EINVAL);
+}
+
+/*
+ * inode-i_mutex: don't care
+ */
+static struct posix_acl *pram_get_acl(struct inode *inode, int type)
+{
+ int name_index;
+ char *value = NULL;
+ struct posix_acl
[PATCH 12/16 v2] pramfs: extended attributes
From: Marco Stornelli marco.storne...@gmail.com
Extended attributes operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/xattr.c linux-2.6.36/fs/pramfs/xattr.c
--- linux-2.6.36-orig/fs/pramfs/xattr.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/xattr.c 2010-09-14 19:45:40.0 +0200
@@ -0,0 +1,1108 @@
+/*
+ * FILE NAME fs/pramfs/xattr.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Extended attributes operations.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * based on fs/ext2/xattr.c with the following copyright:
+ *
+ * Fix by Harrison Xing harri...@mountainviewdata.com.
+ * Extended attributes for symlinks and special files added per
+ * suggestion of Luka Renko luka.re...@hermes.si.
+ * xattr consolidation Copyright (c) 2004 James Morris jmor...@redhat.com,
+ * Red Hat Inc.
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+/*
+ * Extended attributes are stored in blocks allocated outside of
+ * any inode. The i_xattr field is then made to point to this allocated
+ * block. If all extended attributes of an inode are identical, these
+ * inodes may share the same extended attribute block. Such situations
+ * are automatically detected by keeping a cache of recent attribute block
+ * numbers and hashes over the block's contents in memory.
+ *
+ *
+ * Extended attribute block layout:
+ *
+ * +--+
+ * | header |
+ * | entry 1 | |
+ * | entry 2 | | growing downwards
+ * | entry 3 | v
+ * | four null bytes |
+ * | . . .|
+ * | value 1 | ^
+ * | value 3 | | growing upwards
+ * | value 2 | |
+ * +--+
+ *
+ * The block header is followed by multiple entry descriptors. These entry
+ * descriptors are variable in size, and alligned to PRAM_XATTR_PAD
+ * byte boundaries. The entry descriptors are sorted by attribute name,
+ * so that two extended attribute blocks can be compared efficiently.
+ *
+ * Attribute values are aligned to the end of the block, stored in
+ * no specific order. They are also padded to PRAM_XATTR_PAD byte
+ * boundaries. No additional gaps are left between them.
+ *
+ * Locking strategy
+ *
+ * pi-i_xattr is protected by PRAM_I(inode)-xattr_sem.
+ * EA blocks are only changed if they are exclusive to an inode, so
+ * holding xattr_sem also means that nothing but the EA block's reference
+ * count will change. Multiple writers to an EA block are synchronized
+ * by the mutex in each block descriptor. Block descriptors are kept in a
+ * red black tree and the key is the absolute block number.
+ */
+
+#include linux/module.h
+#include linux/init.h
+#include linux/mbcache.h
+#include linux/rwsem.h
+#include linux/security.h
+#include pram.h
+#include xattr.h
+#include acl.h
+#include desctree.h
+
+#define HDR(bp) ((struct pram_xattr_header *)(bp))
+#define ENTRY(ptr) ((struct pram_xattr_entry *)(ptr))
+#define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1)
+#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
+#define GET_DESC(sbi, blocknr) lookup_xblock_desc(sbi, blocknr,
pram_xblock_desc_cache, 1)
+#define LOOKUP_DESC(sbi, blocknr) lookup_xblock_desc(sbi, blocknr, NULL, 0)
+
+#ifdef PRAM_XATTR_DEBUG
+# define ea_idebug(inode, f...) do { \
+ printk(KERN_DEBUG inode %ld: , inode-i_ino); \
+ printk(f); \
+ printk(\n); \
+ } while (0)
+# define ea_bdebug(blocknr, f...) do { \
+ printk(KERN_DEBUG block %lu: , blocknr); \
+ printk(f); \
+ printk(\n); \
+ } while (0)
+#else
+# define ea_idebug(f...)
+# define ea_bdebug(f...)
+#endif
+
+static int pram_xattr_set2(struct inode *, char *, struct pram_xblock_desc *,
struct pram_xattr_header *);
+
+static int pram_xattr_cache_insert(struct super_block *sb, unsigned long
blocknr, u32 xhash);
+static struct pram_xblock_desc *pram_xattr_cache_find(struct inode *,
+struct pram_xattr_header *);
+static void pram_xattr_rehash(struct pram_xattr_header *,
+ struct pram_xattr_entry *);
+
+static struct mb_cache *pram_xattr_cache;
+static struct kmem_cache *pram_xblock_desc_cache;
+
+static const struct xattr_handler *pram_xattr_handler_map[] = {
+ [PRAM_XATTR_INDEX_USER] = pram_xattr_user_handler,
+#ifdef CONFIG_PRAMFS_POSIX_ACL
+ [PRAM_XATTR_INDEX_POSIX_ACL_ACCESS] = pram_xattr_acl_access_handler,
+ [PRAM_XATTR_INDEX_POSIX_ACL_DEFAULT] = pram_xattr_acl_default_handler,
+#endif
+ [PRAM_XATTR_INDEX_TRUSTED] = pram_xattr_trusted_handler,
+#ifdef CONFIG_PRAMFS_SECURITY
+ [PRAM_XATTR_INDEX_SECURITY] = pram_xattr_security_handler,
+#endif
+};
+
+const
[PATCH 13/16 v2] pramfs: xattr block descriptors tree
From: Marco Stornelli marco.storne...@gmail.com
Extended attributes block descriptors tree.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/desctree.c
linux-2.6.36/fs/pramfs/desctree.c
--- linux-2.6.36-orig/fs/pramfs/desctree.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/desctree.c 2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,184 @@
+/*
+ * FILE NAME fs/pramfs/desctree.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Extended attributes block descriptors tree.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/spinlock.h
+#include desctree.h
+#include pram.h
+
+/* xblock_desc_init_always()
+ *
+ * These are initializations that need to be done on every
+ * descriptor allocation as the fields are not initialised
+ * by slab allocation.
+ */
+void xblock_desc_init_always(struct pram_xblock_desc *desc)
+{
+ atomic_set(desc-refcount, 0);
+ desc-blocknr = 0;
+ desc-flags = 0;
+}
+
+/* xblock_desc_init_once()
+ *
+ * These are initializations that only need to be done
+ * once, because the fields are idempotent across use
+ * of the descriptor, so let the slab aware of that.
+ */
+void xblock_desc_init_once(struct pram_xblock_desc *desc)
+{
+ mutex_init(desc-lock);
+}
+
+/* __insert_xblock_desc()
+ *
+ * Insert a new descriptor in the tree.
+ *
+ */
+static void __insert_xblock_desc(struct pram_sb_info *sbi,
+unsigned long blocknr, struct rb_node *node)
+{
+ struct rb_node **p = (sbi-desc_tree.rb_node);
+ struct rb_node *parent = NULL;
+ struct pram_xblock_desc *desc;
+
+ while (*p) {
+ parent = *p;
+ desc = rb_entry(parent, struct pram_xblock_desc, node);
+
+ if (blocknr desc-blocknr)
+ p = (*p)-rb_left;
+ else if (blocknr desc-blocknr)
+ p = (*p)-rb_right;
+ else
+ /* Oops...an other descriptor for the same block ? */
+ BUG();
+ }
+
+ rb_link_node(node, parent, p);
+ rb_insert_color(node, sbi-desc_tree);
+}
+
+void insert_xblock_desc(struct pram_sb_info *sbi, struct pram_xblock_desc
*desc)
+{
+ spin_lock(sbi-desc_tree_lock);
+ __insert_xblock_desc(sbi, desc-blocknr, desc-node);
+ spin_unlock(sbi-desc_tree_lock);
+};
+
+/* __lookup_xblock_desc()
+ *
+ * Search an extended attribute descriptor in the tree via the
+ * block number. It returns the descriptor if it's found or
+ * NULL. If not found it creates a new descriptor if create is not 0.
+ */
+static struct pram_xblock_desc *__lookup_xblock_desc(struct pram_sb_info *sbi,
+ unsigned long blocknr,
+ struct kmem_cache *cache,
+ int create)
+{
+ struct rb_node *n = sbi-desc_tree.rb_node;
+ struct pram_xblock_desc *desc = NULL;
+
+ while (n) {
+ desc = rb_entry(n, struct pram_xblock_desc, node);
+
+ if (blocknr desc-blocknr)
+ n = n-rb_left;
+ else if (blocknr desc-blocknr)
+ n = n-rb_right;
+ else {
+ atomic_inc(desc-refcount);
+ goto out;
+ }
+ }
+
+ /* not found */
+ if (create) {
+ desc = kmem_cache_alloc(cache, GFP_NOFS);
+ if (!desc)
+ return ERR_PTR(-ENOMEM);
+ xblock_desc_init_always(desc);
+ atomic_set(desc-refcount, 1);
+ desc-blocknr = blocknr;
+ __insert_xblock_desc(sbi, desc-blocknr, desc-node);
+ }
+out:
+ return desc;
+}
+
+struct pram_xblock_desc *lookup_xblock_desc(struct pram_sb_info *sbi,
+ unsigned long blocknr,
+ struct kmem_cache *cache,
+ int create)
+{
+ struct pram_xblock_desc *desc = NULL;
+
+ spin_lock(sbi-desc_tree_lock);
+ desc = __lookup_xblock_desc(sbi, blocknr, cache, create);
+ spin_unlock(sbi-desc_tree_lock);
+ return desc;
+}
+
+/* put_xblock_desc()
+ *
+ * Decrement the reference count and if it reaches zero and the
+ * desciptor has been marked to be free, then we free it.
+ * It returns 0 if the descriptor has been deleted and 1 otherwise.
+ */
+int put_xblock_desc(struct pram_sb_info *sbi, struct pram_xblock_desc *desc)
+{
+ int ret = 1;
+ if (!desc)
+ return ret;
+
+ if (atomic_dec_and_lock(desc-refcount, sbi-desc_tree_lock
[PATCH 15/16 v2] pramfs: test module
From: Marco Stornelli marco.storne...@gmail.com
Test module.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/pramfs_test.c
linux-2.6.36/fs/pramfs/pramfs_test.c
--- linux-2.6.36-orig/fs/pramfs/pramfs_test.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/pramfs_test.c2010-09-14 18:49:52.0
+0200
@@ -0,0 +1,49 @@
+/*
+ * FILE NAME fs/pramfs/namei.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Pramfs test module.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/module.h
+#include linux/version.h
+#include linux/init.h
+#include linux/fs.h
+#include pram.h
+
+int __init test_pramfs_write(void)
+{
+ struct pram_super_block *psb;
+
+ psb = get_pram_super();
+ if (!psb) {
+ printk(KERN_ERR
+ %s: PRAMFS super block not found (not mounted?)\n,
+ __func__);
+ return 1;
+ }
+
+ /*
+* Attempt an unprotected clear of checksum information in the
+* superblock, this should cause a kernel page protection fault.
+*/
+ printk(%s: writing to kernel VA %p\n, __func__, psb);
+ psb-s_sum = 0;
+
+ return 0;
+}
+
+void test_pramfs_write_cleanup(void) {}
+
+/* Module information */
+MODULE_LICENSE(GPL);
+module_init(test_pramfs_write);
+module_exit(test_pramfs_write_cleanup);
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 16/16 v2] pramfs: Makefile and Kconfig
From: Marco Stornelli marco.storne...@gmail.com Makefile and Kconfig. Signed-off-by: Marco Stornelli marco.storne...@gmail.com --- diff -Nurp linux-2.6.36-orig/fs/Makefile linux-2.6.36/fs/Makefile --- linux-2.6.36-orig/fs/Makefile 2010-09-13 01:07:37.0 +0200 +++ linux-2.6.36/fs/Makefile2010-09-14 18:49:52.0 +0200 @@ -126,3 +126,4 @@ obj-$(CONFIG_BTRFS_FS) += btrfs/ obj-$(CONFIG_GFS2_FS) += gfs2/ obj-$(CONFIG_EXOFS_FS) += exofs/ obj-$(CONFIG_CEPH_FS) += ceph/ +obj-$(CONFIG_PRAMFS) += pramfs/ diff -Nurp linux-2.6.36-orig/fs/Kconfig linux-2.6.36/fs/Kconfig --- linux-2.6.36-orig/fs/Kconfig2010-09-13 01:07:37.0 +0200 +++ linux-2.6.36/fs/Kconfig 2010-09-14 18:49:52.0 +0200 @@ -13,7 +13,7 @@ source fs/ext4/Kconfig config FS_XIP # execute in place bool - depends on EXT2_FS_XIP + depends on EXT2_FS_XIP || PRAMFS_XIP default y source fs/jbd/Kconfig @@ -25,13 +25,14 @@ config FS_MBCACHE default y if EXT2_FS=y EXT2_FS_XATTR default y if EXT3_FS=y EXT3_FS_XATTR default y if EXT4_FS=y EXT4_FS_XATTR - default m if EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4_FS_XATTR + default y if PRAMFS=y PRAMFS_XATTR + default m if EXT2_FS_XATTR || EXT3_FS_XATTR || EXT4_FS_XATTR || PRAMFS_XATTR source fs/reiserfs/Kconfig source fs/jfs/Kconfig config FS_POSIX_ACL -# Posix ACL utility routines (for now, only ext2/ext3/jfs/reiserfs/nfs4) +# Posix ACL utility routines (for now, only ext2/ext3/jfs/reiserfs/nfs4/pramfs) # # NOTE: you can implement Posix ACLs without these helpers (XFS does). # Never use this symbol for ifdefs. @@ -189,6 +190,7 @@ source fs/romfs/Kconfig source fs/sysv/Kconfig source fs/ufs/Kconfig source fs/exofs/Kconfig +source fs/pramfs/Kconfig endif # MISC_FILESYSTEMS diff -Nurp linux-2.6.36-orig/fs/pramfs/Kconfig linux-2.6.36/fs/pramfs/Kconfig --- linux-2.6.36-orig/fs/pramfs/Kconfig 1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/fs/pramfs/Kconfig 2010-10-30 10:30:19.0 +0200 @@ -0,0 +1,72 @@ +config PRAMFS + tristate Persistent and Protected RAM file system support + depends on HAS_IOMEM EXPERIMENTAL + select CRC16 + help + If your system has a block of fast (comparable in access speed to + system memory) and non-volatile RAM and you wish to mount a + light-weight, full-featured, and space-efficient filesystem over it, + say Y here, and read file:Documentation/filesystems/pramfs.txt. + + To compile this as a module, choose M here: the module will be + called pramfs. + +config PRAMFS_XIP + bool Enable Execute-in-place in PRAMFS + depends on PRAMFS !PRAMFS_WRITE_PROTECT + help + Say Y here to enable XIP feature of PRAMFS. + +config PRAMFS_WRITE_PROTECT + bool Enable PRAMFS write protection + depends on PRAMFS MMU HAVE_SET_MEMORY_RO + default y + help + Say Y here to enable the write protect feature of PRAMFS. + +config PRAMFS_XATTR + bool PRAMFS extended attributes + depends on PRAMFS + help + Extended attributes are name:value pairs associated with inodes by + the kernel or by users (see the attr(5) manual page, or visit + http://acl.bestbits.at/ for details). + + If unsure, say N. + +config PRAMFS_POSIX_ACL + bool PRAMFS POSIX Access Control Lists + depends on PRAMFS_XATTR + select FS_POSIX_ACL + help + Posix Access Control Lists (ACLs) support permissions for users and + groups beyond the owner/group/world scheme. + + To learn more about Access Control Lists, visit the Posix ACLs for + Linux website http://acl.bestbits.at/. + + If you don't know what Access Control Lists are, say N. + +config PRAMFS_SECURITY + bool PRAMFS Security Labels + depends on PRAMFS_XATTR + help + Security labels support alternative access control models + implemented by security modules like SELinux. This option + enables an extended attribute handler for file security + labels in the pram filesystem. + + If you are not using a security module that requires using + extended attributes for file security labels, say N. + +config PRAMFS_TEST + boolean + depends on PRAMFS + +config TEST_MODULE + tristate PRAMFS Test + depends on PRAMFS m + select PRAMFS_TEST + help + Say Y here to build a simple module to test the protection of + PRAMFS. The module will be called pramfs_test. diff -Nurp linux-2.6.36-orig/fs/pramfs/Makefile linux-2.6.36/fs/pramfs/Makefile --- linux-2.6.36-orig/fs/pramfs/Makefile1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/fs/pramfs/Makefile 2010-09-14 18:49:52.0 +0200 @@ -0,0 +1,14 @@ +# +# Makefile for the linux
Re: [PATCH 01/16 v2] pramfs: documentation
Il 06/11/2010 11:39, James Hogan ha scritto: Hi, On Sat, Nov 06, 2010 at 09:56:18AM +0100, Marco Stornelli wrote: From: Marco Stornelli marco.storne...@gmail.com +PRAMFS is write protected. The page table entries that map the backing-store +RAM are normally marked read-only. Write operations into the filesystem +temporarily mark the affected pages as writeable, the write operation is +carried out with locks held, and then the page table entries is +marked read-only again. +This feature provides protection against filesystem corruption caused by errant Looks like an accidental lost newline in the patch here, should that be are marked or is there some text missing? My fault, a problem during email formatting. I'll resend this patch. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 02/16 v2] pramfs: super block operations
Il 06/11/2010 12:16, James Hogan ha scritto:
Hi Marco,
On Sat, Nov 06, 2010 at 09:56:39AM +0100, Marco Stornelli wrote:
From: Marco Stornelli marco.storne...@gmail.com
+static void pram_set_blocksize(struct super_block *sb, unsigned long size)
+{
+int bits;
+
+/*
+* We've already validated the user input and the value here must be
+* between PRAM_MAX_BLOCK_SIZE and PRAM_MIN_BLOCK_SIZE
+* and it must be a power of 2.
+*/
Should this comment have spaces after the tabs to be consistent with the
other multiline comments (pram_ioremap) and the coding style?
Ok, no problem.
Thanks for the review.
Regards,
Marco
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 10/16 v2] pramfs: XIP operations
Il 06/11/2010 14:33, James Hogan ha scritto:
Hi,
On Sat, Nov 06, 2010 at 09:59:27AM +0100, Marco Stornelli wrote:
diff -Nurp linux-2.6.36-orig/fs/pramfs/xip.c linux-2.6.36/fs/pramfs/xip.c
--- linux-2.6.36-orig/fs/pramfs/xip.c1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/xip.c 2010-09-14 18:49:52.0 +0200
snip
+static int pram_find_and_alloc_blocks(struct inode *inode, sector_t iblock,
+ sector_t *data_block, int create)
+{
+int err = -EIO;
+u64 block;
+
+mutex_lock(PRAM_I(inode)-truncate_lock);
fs/pramfs/xip.c: In function ‘pram_find_and_alloc_blocks’:
fs/pramfs/xip.c:27: error: ‘struct pram_inode_vfs’ has no member named
‘truncate_lock’
fs/pramfs/xip.c:52: error: ‘struct pram_inode_vfs’ has no member named
‘truncate_lock’
i guess that should be truncate_mutex.
Oops, my fault, yes it's truncate_mutex. I'll fix it asap.
Marco
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 14(16] pramfs: memory protection
2010/10/12 Andi Kleen a...@firstfloor.org: On Mon, Oct 11, 2010 at 07:32:10PM +0200, Marco Stornelli wrote: Il 10/10/2010 18:46, Andi Kleen ha scritto: This won't work at all on x86 because you don't handle large pages. And it doesn't work on x86-64 because the first 2GB are double mapped (direct and kernel text mapping) Thirdly I expect it won't either on architectures that map the direct mapping with special registers (like IA64 or MIPS) Andi, what do you think to use the already implemented follow_pte instead? Has all the same problems. Really you need an per architecture function. Perhaps some architectures could use a common helper, but certainly not all. per-arch?! Wow. Mmm...maybe I have to change something at fs level to avoid that. An alternative could be to use the follow_pte solution but avoid the protection via Kconfig if the fs is used on some archs (ia64 or MIPS), with large pages and so on. An help of the kernel community to know all these particular cases is welcome. Regards, Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 14(16] pramfs: memory protection
2010/10/10 Andi Kleen a...@firstfloor.org:
Marco Stornelli marco.storne...@gmail.com writes:
+
+ do {
+ pgd = pgd_offset(init_mm, address);
+ if (pgd_none(*pgd) || unlikely(pgd_bad(*pgd)))
+ goto out;
+
+ pud = pud_offset(pgd, address);
+ if (pud_none(*pud) || unlikely(pud_bad(*pud)))
+ goto out;
+
+ pmd = pmd_offset(pud, address);
+ if (pmd_none(*pmd) || unlikely(pmd_bad(*pmd)))
+ goto out;
+
+ ptep = pte_offset_kernel(pmd, addr);
+ pte = *ptep;
+ if (pte_present(pte)) {
This won't work at all on x86 because you don't handle large
pages.
On x86 works because I tested. Maybe there's a particular
configuration with large pages. Sincerly I'm only an user, so if
you/Linus or others want to change it or rewrite it, for me it's ok.
The pte manipulation are a bit out of scope for a fs, so I let the
things to the mm experts.
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 15/16] pramfs: test module
2010/10/10 Randy Dunlap rdun...@xenotime.net:
On Sun, 10 Oct 2010 18:37:49 +0200 Marco Stornelli wrote:
Above 2 lines need to indented more.
Ack.
+ return 1;
+ }
+
+ /*
+ * Attempt an unprotected clear of checksum information in the
+ * superblock, this should cause a kernel page protection fault.
+ */
+ printk(%s: writing to kernel VA %p\n, __func__, psb);
+ psb-s_sum = 0;
+
+ return 0;
+}
+
+void test_pramfs_write_cleanup(void) {}
+
+/* Module information */
+MODULE_LICENSE(GPL);
+module_init(test_pramfs_write);
+module_exit(test_pramfs_write_cleanup);
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 16/16] pramfs Makefile and Kconfig
2010/10/10 Randy Dunlap rdun...@xenotime.net:
On Sun, 10 Oct 2010 18:39:11 +0200 Marco Stornelli wrote:
From: Marco Stornelli marco.storne...@gmail.com
Makefile and Kconfig.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/Kconfig
linux-2.6.36/fs/pramfs/Kconfig
--- linux-2.6.36-orig/fs/pramfs/Kconfig 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/Kconfig 2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,72 @@
+config PRAMFS
+ tristate Persistent and Protected RAM file system support
+ depends on HAS_IOMEM EXPERIMENTAL
+ select CRC16
+ help
+ If your system has a block of fast (comparable in access speed to
+ system memory) and non-volatile RAM and you wish to mount a
+ light-weight, full-featured, and space-efficient filesystem over it,
+ say Y here, and read file:Documentation/filesystems/pramfs.txt.
+
+ To compile this as a module, choose M here: the module will be
+ called pramfs.ko.
called pramfs.
(we don't add the .ko suffix; well, we try not to do that)
Ok.
+
+config PRAMFS_XIP
+ bool Enable Execute-in-place in PRAMFS
+ depends on PRAMFS !PRAMFS_WRITE_PROTECT
+ help
+ Say Y here to enable xip feature of PRAMFS.
XIP
Ok.
+
+config PRAMFS_WRITE_PROTECT
+ bool Enable PRAMFS write protection
+ depends on PRAMFS MMU
+ default y
+ help
+ Say Y here to enable the write protect feature of PRAMFS.
+
+config PRAMFS_XATTR
+ bool PRAMFS extended attributes
+ depends on PRAMFS
+ help
+ Extended attributes are name:value pairs associated with inodes by
+ the kernel or by users (see the attr(5) manual page, or visit
+ http://acl.bestbits.at/ for details).
+
+ If unsure, say N.
+
+config PRAMFS_POSIX_ACL
+ bool PRAMFS POSIX Access Control Lists
+ depends on PRAMFS_XATTR
+ select FS_POSIX_ACL
+ help
+ Posix Access Control Lists (ACLs) support permissions for users and
+ groups beyond the owner/group/world scheme.
+
+ To learn more about Access Control Lists, visit the Posix ACLs for
+ Linux website http://acl.bestbits.at/.
+
+ If you don't know what Access Control Lists are, say N
end sentence with period ('.').
Ok.
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 11/16] pramfs: ACL management
Il 11/10/2010 14:26, Kieran Bingham ha scritto: On 10/10/2010 17:33, Marco Stornelli wrote: From: Marco Stornellimarco.storne...@gmail.com ACL operations. Signed-off-by: Marco Stornellimarco.storne...@gmail.com --- diff -Nurp linux-2.6.36-orig/fs/pramfs/acl.c linux-2.6.36/fs/pramfs/acl.c --- linux-2.6.36-orig/fs/pramfs/acl.c1970-01-01 01:00:00.0 +0100 +++ linux-2.6.36/fs/pramfs/acl.c2010-09-14 18:49:52.0 +0200 @@ -0,0 +1,418 @@ +/* + * FILE NAME fs/pramfs/acl.h Found another one :) FILE NAME != acl.h ... -- KB Oops, damn copypaste ;) I'll fix it asap. Thanks. Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 14(16] pramfs: memory protection
Il 10/10/2010 18:46, Andi Kleen ha scritto:
This won't work at all on x86 because you don't handle large
pages.
And it doesn't work on x86-64 because the first 2GB are double
mapped (direct and kernel text mapping)
Thirdly I expect it won't either on architectures that map
the direct mapping with special registers (like IA64 or MIPS)
Andi, what do you think to use the already implemented follow_pte
instead?
int writeable_kernel_pte_range(unsigned long address, unsigned long size,
unsigned int rw)
{
unsigned long addr = address PAGE_MASK;
unsigned long end = address + size;
unsigned long start = addr;
int ret = -EINVAL;
pte_t *ptep, pte;
spinlock_t *lock = init_mm.page_table_lock;
do {
ret = follow_pte(init_mm, addr, ptep, lock);
if (ret)
goto out;
pte = *ptep;
if (pte_present(pte)) {
pte = rw ? pte_mkwrite(pte) : pte_wrprotect(pte);
*ptep = pte;
}
pte_unmap_unlock(ptep, lock);
addr += PAGE_SIZE;
} while (addr (addr end));
ret = 0;
out:
flush_tlb_kernel_range(start, end);
return ret;
}
I'm not sure this is very useful anyways. It doesn't protect
against stray DMA and it doesn't protect against writes through
broken user PTEs.
-Andi
It's a way to have more protection against kernel bug, for a
in-memory fs can be important. However this option can be
enabled/disabled at fs level.
Marco
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 00/16] pramfs: persistent and protected RAM Filesystem
Hi all, after a lot of improvement, test, bug fix and new features, it's the moment for third round with the kernel community to submit PRAMFS for mainline. Since the last review (June 2009) a lot of things are changed: - removed any reference of BKL - fixed the endianess for the fs layout - added support for extended attributes, ACLs and security labels - moved out any pte manipulations from fs and inserted them in mm - implemented the new truncate convention - fixed problems with 64bit archs ...and much more. Complete story in the ChangeLog inserted in the documentation file. In addition, in the web site tech page (http:\\pramfs.sourceforge.net), you can find a lot of information about implementation, technical details, benchmarking and so on. All the work to mainline this feature is sponsored by the CE Linux Forum. Regards, Marco -- To unsubscribe from this list: send the line unsubscribe linux-embedded in the body of a message to majord...@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 02/16] pramfs: super block operations
From: Marco Stornelli marco.storne...@gmail.com
Super block operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/super.c linux-2.6.36/fs/pramfs/super.c
--- linux-2.6.36-orig/fs/pramfs/super.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/super.c 2010-09-25 14:09:47.0 +0200
@@ -0,0 +1,740 @@
+/*
+ * FILE NAME fs/pramfs/super.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Super block operations.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/module.h
+#include linux/string.h
+#include linux/slab.h
+#include linux/init.h
+#include linux/blkdev.h
+#include linux/parser.h
+#include linux/vfs.h
+#include linux/uaccess.h
+#include linux/io.h
+#include linux/seq_file.h
+#include linux/mount.h
+#include linux/mm.h
+#include linux/ctype.h
+#include linux/bitops.h
+#include linux/magic.h
+#include linux/exportfs.h
+#include linux/random.h
+#include xattr.h
+#include pram.h
+
+static struct super_operations pram_sops;
+static const struct export_operations pram_export_ops;
+static struct kmem_cache *pram_inode_cachep;
+
+#ifdef CONFIG_PRAMFS_TEST
+static void *first_pram_super;
+
+struct pram_super_block *get_pram_super(void)
+{
+ return (struct pram_super_block *)first_pram_super;
+}
+EXPORT_SYMBOL(get_pram_super);
+#endif
+
+static void pram_set_blocksize(struct super_block *sb, unsigned long size)
+{
+ int bits;
+
+ /*
+ * We've already validated the user input and the value here must be
+ * between PRAM_MAX_BLOCK_SIZE and PRAM_MIN_BLOCK_SIZE
+ * and it must be a power of 2.
+ */
+ bits = fls(size) - 1;
+ sb-s_blocksize_bits = bits;
+ sb-s_blocksize = (1bits);
+}
+
+static inline void *pram_ioremap(phys_addr_t phys_addr, ssize_t size)
+{
+ void *retval;
+
+ /*
+* NOTE: Userland may not map this resource, we will mark the region so
+* /dev/mem and the sysfs MMIO access will not be allowed. This
+* restriction depends on STRICT_DEVMEM option. If this option is
+* disabled or not available we mark the region only as busy.
+*/
+ retval = request_mem_region_exclusive(phys_addr, size, pramfs);
+ if (!retval)
+ goto fail;
+
+ retval = ioremap_nocache(phys_addr, size);
+
+ if (retval)
+ wrprotect(retval, size);
+fail:
+ return retval;
+}
+
+static loff_t pram_max_size(int bits)
+{
+ loff_t res;
+ res = (1ULL (3*bits - 6)) - 1;
+
+ if (res MAX_LFS_FILESIZE)
+ res = MAX_LFS_FILESIZE;
+
+ pram_info(Max file size %llu bytes, res);
+ return res;
+}
+
+enum {
+ Opt_addr, Opt_bpi, Opt_size,
+ Opt_num_inodes, Opt_mode, Opt_uid,
+ Opt_gid, Opt_blocksize, Opt_err
+};
+
+static const match_table_t tokens = {
+ {Opt_bpi, physaddr=%x},
+ {Opt_bpi, bpi=%u},
+ {Opt_size, init=%s},
+ {Opt_num_inodes, N=%u},
+ {Opt_mode, mode=%o},
+ {Opt_uid, uid=%u},
+ {Opt_gid, gid=%u},
+ {Opt_blocksize, bs=%s},
+ {Opt_err, NULL},
+};
+
+static phys_addr_t get_phys_addr(void **data)
+{
+ phys_addr_t phys_addr;
+ char *options = (char *) *data;
+
+ if (!options || strncmp(options, physaddr=, 9) != 0)
+ return (phys_addr_t)ULLONG_MAX;
+ options += 9;
+ phys_addr = (phys_addr_t)simple_strtoull(options, options, 0);
+ if (*options *options != ',') {
+ pram_err(Invalid phys addr specification: %s\n,
+ (char *) *data);
+ return (phys_addr_t)ULLONG_MAX;
+ }
+ if (phys_addr (PAGE_SIZE - 1)) {
+ pram_err(physical address 0x%16llx for pramfs isn't
+ aligned to a page boundary\n,
+ (u64)phys_addr);
+ return (phys_addr_t)ULLONG_MAX;
+ }
+ if (*options == ',')
+ options++;
+ *data = (void *) options;
+ return phys_addr;
+}
+
+static int pram_parse_options(char *options, struct pram_sb_info *sbi)
+{
+ char *p, *rest;
+ substring_t args[MAX_OPT_ARGS];
+ int option;
+
+ if (!options)
+ return 0;
+
+ while ((p = strsep(options, ,)) != NULL) {
+ int token;
+ if (!*p)
+ continue;
+
+ token = match_token(p, tokens, args);
+ switch (token) {
+ case Opt_addr: {
+ /* physaddr managed
[PATCH 06/16] pramfs: inode operations for dirs
From: Marco Stornelli marco.storne...@gmail.com
Inode operations for directories.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/namei.c linux-2.6.36/fs/pramfs/namei.c
--- linux-2.6.36-orig/fs/pramfs/namei.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/namei.c 2010-09-18 12:00:35.0 +0200
@@ -0,0 +1,363 @@
+/*
+ * FILE NAME fs/pramfs/namei.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Inode operations for directories.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+#include linux/fs.h
+#include linux/pagemap.h
+#include pram.h
+#include acl.h
+#include xattr.h
+
+/*
+ * Couple of helper functions - make the code slightly cleaner.
+ */
+
+static inline void pram_inc_count(struct inode *inode)
+{
+ inode-i_nlink++;
+ pram_write_inode(inode, 0);
+}
+
+static inline void pram_dec_count(struct inode *inode)
+{
+ if (inode-i_nlink) {
+ inode-i_nlink--;
+ pram_write_inode(inode, 0);
+ }
+}
+
+static inline int pram_add_nondir(struct inode *dir,
+ struct dentry *dentry,
+ struct inode *inode)
+{
+ int err = pram_add_link(dentry, inode);
+ if (!err) {
+ d_instantiate(dentry, inode);
+ unlock_new_inode(inode);
+ return 0;
+ }
+ pram_dec_count(inode);
+ unlock_new_inode(inode);
+ iput(inode);
+ return err;
+}
+
+/*
+ * Methods themselves.
+ */
+
+static ino_t
+pram_inode_by_name(struct inode *dir,
+ struct dentry *dentry)
+{
+ struct pram_inode *pi;
+ ino_t ino;
+ int namelen;
+
+ pi = pram_get_inode(dir-i_sb, dir-i_ino);
+ ino = be64_to_cpu(pi-i_type.dir.head);
+
+ while (ino) {
+ pi = pram_get_inode(dir-i_sb, ino);
+
+ if (pi-i_links_count) {
+ namelen = strlen(pi-i_d.d_name);
+
+ if (namelen == dentry-d_name.len
+ !memcmp(dentry-d_name.name,
+ pi-i_d.d_name, namelen))
+ break;
+ }
+
+ ino = be64_to_cpu(pi-i_d.d_next);
+ }
+
+ return ino;
+}
+
+static struct dentry *
+pram_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+{
+ struct inode *inode = NULL;
+ ino_t ino;
+
+ if (dentry-d_name.len PRAM_NAME_LEN)
+ return ERR_PTR(-ENAMETOOLONG);
+
+ ino = pram_inode_by_name(dir, dentry);
+ if (ino) {
+ inode = pram_iget(dir-i_sb, ino);
+ if (!inode)
+ return ERR_PTR(-EACCES);
+ }
+
+ d_splice_alias(inode, dentry);
+ return NULL;
+}
+
+
+/*
+ * By the time this is called, we already have created
+ * the directory cache entry for the new file, but it
+ * is so far negative - it has no inode.
+ *
+ * If the create succeeds, we fill in the inode information
+ * with d_instantiate().
+ */
+static int pram_create(struct inode *dir, struct dentry *dentry,
+ int mode, struct nameidata *nd)
+{
+ struct inode *inode = pram_new_inode(dir, mode);
+ int err = PTR_ERR(inode);
+ if (!IS_ERR(inode)) {
+
+ inode-i_op = pram_file_inode_operations;
+ inode-i_fop = pram_file_operations;
+ inode-i_mapping-a_ops = pram_aops;
+ err = pram_add_nondir(dir, dentry, inode);
+ }
+ return err;
+}
+
+static int pram_mknod(struct inode *dir, struct dentry *dentry, int mode,
+ dev_t rdev)
+{
+ struct inode *inode = pram_new_inode(dir, mode);
+ int err = PTR_ERR(inode);
+ if (!IS_ERR(inode)) {
+ init_special_inode(inode, mode, rdev);
+ pram_write_inode(inode, 0); /* update rdev */
+ err = pram_add_nondir(dir, dentry, inode);
+ }
+ return err;
+}
+
+static int pram_symlink(struct inode *dir,
+ struct dentry *dentry,
+ const char *symname)
+{
+ struct super_block *sb = dir-i_sb;
+ int err = -ENAMETOOLONG;
+ unsigned len = strlen(symname);
+ struct inode *inode;
+
+ if (len+1 sb-s_blocksize)
+ goto out;
+
+ inode = pram_new_inode(dir, S_IFLNK | S_IRWXUGO);
+ err = PTR_ERR(inode);
+ if (IS_ERR(inode))
+ goto out;
+
+ inode-i_op = pram_symlink_inode_operations;
+ inode-i_mapping-a_ops = pram_aops
[PATCH 05/16] pramfs: block allocation
From: Marco Stornelli marco.storne...@gmail.com
Block allocation operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/balloc.c linux-2.6.36/fs/pramfs/balloc.c
--- linux-2.6.36-orig/fs/pramfs/balloc.c1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/balloc.c 2010-09-26 18:05:06.0 +0200
@@ -0,0 +1,155 @@
+/*
+ * FILE NAME fs/pramfs/balloc.c
+ *
+ * BRIEF MODULE DESCRIPTION
+ *
+ * The blocks allocation and deallocation routines.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/bitops.h
+#include pram.h
+
+/*
+ * This just marks in-use the blocks that make up the bitmap.
+ * The bitmap must be writeable before calling.
+ */
+void pram_init_bitmap(struct super_block *sb)
+{
+ struct pram_super_block *ps = pram_get_super(sb);
+ u64 *bitmap = pram_get_bitmap(sb);
+ int blocks = be32_to_cpu(ps-s_bitmap_blocks);
+
+ memset(bitmap, 0, blocks sb-s_blocksize_bits);
+
+ while (blocks = 64) {
+ *bitmap++ = (u64)ULLONG_MAX;
+ blocks -= 64;
+ }
+
+ if (blocks)
+ *bitmap = cpu_to_le64((1ULL blocks) - 1);
+}
+
+
+/* Free absolute blocknr */
+void pram_free_block(struct super_block *sb, unsigned long blocknr)
+{
+ struct pram_super_block *ps;
+ u64 bitmap_block;
+ unsigned long bitmap_bnr;
+ void *bitmap;
+ void *bp;
+
+ lock_super(sb);
+
+ bitmap = pram_get_bitmap(sb);
+ /*
+* find the block within the bitmap that contains the inuse bit
+* for the block we need to free. We need to unlock this bitmap
+* block to clear the inuse bit.
+*/
+ bitmap_bnr = blocknr (3 + sb-s_blocksize_bits);
+ bitmap_block = pram_get_block_off(sb, bitmap_bnr);
+ bp = pram_get_block(sb, bitmap_block);
+
+ pram_memunlock_block(sb, bp);
+ pram_clear_bit(blocknr, bitmap); /* mark the block free */
+ pram_memlock_block(sb, bp);
+
+ ps = pram_get_super(sb);
+ pram_memunlock_super(ps);
+ if (blocknr be32_to_cpu(ps-s_free_blocknr_hint))
+ ps-s_free_blocknr_hint = cpu_to_be32(blocknr);
+ be32_add_cpu(ps-s_free_blocks_count, 1);
+ pram_memlock_super(ps);
+
+ unlock_super(sb);
+}
+
+
+/*
+ * allocate a block and return it's absolute blocknr. Zeroes out the
+ * block if zero set.
+ */
+int pram_new_block(struct super_block *sb, unsigned long *blocknr, int zero)
+{
+ struct pram_super_block *ps;
+ off_t bitmap_block;
+ unsigned long bnr, bitmap_bnr;
+ int errval;
+ void *bitmap;
+ void *bp;
+
+ lock_super(sb);
+ ps = pram_get_super(sb);
+ bitmap = pram_get_bitmap(sb);
+
+ if (ps-s_free_blocks_count) {
+ /* find the oldest unused block */
+ bnr = pram_find_next_zero_bit(bitmap,
+be32_to_cpu(ps-s_blocks_count),
+be32_to_cpu(ps-s_free_blocknr_hint));
+
+ if (bnr be32_to_cpu(ps-s_bitmap_blocks) ||
+ bnr = be32_to_cpu(ps-s_blocks_count)) {
+ pram_err(no free blocks found!\n);
+ errval = -ENOSPC;
+ goto fail;
+ }
+
+ pram_dbg(allocating blocknr %lu\n, bnr);
+ pram_memunlock_super(ps);
+ be32_add_cpu(ps-s_free_blocks_count, -1);
+ if (bnr (be32_to_cpu(ps-s_blocks_count)-1))
+ ps-s_free_blocknr_hint = cpu_to_be32(bnr+1);
+ else
+ ps-s_free_blocknr_hint = 0;
+ pram_memlock_super(ps);
+ } else {
+ pram_err(all blocks allocated\n);
+ errval = -ENOSPC;
+ goto fail;
+ }
+
+ /*
+* find the block within the bitmap that contains the inuse bit
+* for the unused block we just found. We need to unlock it to
+* set the inuse bit.
+*/
+ bitmap_bnr = bnr (3 + sb-s_blocksize_bits);
+ bitmap_block = pram_get_block_off(sb, bitmap_bnr);
+ bp = pram_get_block(sb, bitmap_block);
+
+ pram_memunlock_block(sb, bp);
+ pram_set_bit(bnr, bitmap); /* mark the new block in use */
+ pram_memlock_block(sb, bp);
+
+ if (zero) {
+ bp = pram_get_block(sb, pram_get_block_off(sb, bnr));
+ pram_memunlock_block(sb, bp);
+ memset(bp, 0, sb-s_blocksize
[PATCH 07/16] pramfs: symbolic links
From: Marco Stornelli marco.storne...@gmail.com
Symlink operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/symlink.c
linux-2.6.36/fs/pramfs/symlink.c
--- linux-2.6.36-orig/fs/pramfs/symlink.c 1970-01-01 01:00:00.0
+0100
+++ linux-2.6.36/fs/pramfs/symlink.c2010-09-14 18:49:52.0 +0200
@@ -0,0 +1,78 @@
+/*
+ * FILE NAME fs/pramfs/symlink.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Symlink operations
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include pram.h
+#include xattr.h
+
+int pram_block_symlink(struct inode *inode, const char *symname, int len)
+{
+ struct super_block *sb = inode-i_sb;
+ u64 block;
+ char *blockp;
+ int err;
+
+ err = pram_alloc_blocks(inode, 0, 1);
+ if (err)
+ return err;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+
+ pram_memunlock_block(sb, blockp);
+ memcpy(blockp, symname, len);
+ blockp[len] = '\0';
+ pram_memlock_block(sb, blockp);
+ return 0;
+}
+
+static int pram_readlink(struct dentry *dentry, char *buffer, int buflen)
+{
+ struct inode *inode = dentry-d_inode;
+ struct super_block *sb = inode-i_sb;
+ u64 block;
+ char *blockp;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+ return vfs_readlink(dentry, buffer, buflen, blockp);
+}
+
+static void *pram_follow_link(struct dentry *dentry, struct nameidata *nd)
+{
+ struct inode *inode = dentry-d_inode;
+ struct super_block *sb = inode-i_sb;
+ off_t block;
+ int status;
+ char *blockp;
+
+ block = pram_find_data_block(inode, 0);
+ blockp = pram_get_block(sb, block);
+ status = vfs_follow_link(nd, blockp);
+ return ERR_PTR(status);
+}
+
+struct inode_operations pram_symlink_inode_operations = {
+ .readlink = pram_readlink,
+ .follow_link= pram_follow_link,
+ .setattr= pram_notify_change,
+#ifdef CONFIG_PRAMFS_XATTR
+ .setxattr = generic_setxattr,
+ .getxattr = generic_getxattr,
+ .listxattr = pram_listxattr,
+ .removexattr= generic_removexattr,
+#endif
+};
--
To unsubscribe from this list: send the line unsubscribe linux-embedded in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
[PATCH 09/16] pramfs: dir operations
From: Marco Stornelli marco.storne...@gmail.com
File operations for directories.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/dir.c linux-2.6.36/fs/pramfs/dir.c
--- linux-2.6.36-orig/fs/pramfs/dir.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/dir.c2010-09-17 19:08:54.0 +0200
@@ -0,0 +1,215 @@
+/*
+ * FILE NAME fs/pramfs/dir.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * File operations for directories.
+ *
+ * Copyright 2009-2010 Marco Stornelli marco.storne...@gmail.com
+ * Copyright 2003 Sony Corporation
+ * Copyright 2003 Matsushita Electric Industrial Co., Ltd.
+ * 2003-2004 (c) MontaVista Software, Inc. , Steve Longerbeam
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include linux/fs.h
+#include linux/pagemap.h
+#include pram.h
+
+/*
+ * Parent is locked.
+ */
+int pram_add_link(struct dentry *dentry, struct inode *inode)
+{
+ struct inode *dir = dentry-d_parent-d_inode;
+ struct pram_inode *pidir, *pi, *pitail = NULL;
+ u64 tail_ino, prev_ino;
+
+ const char *name = dentry-d_name.name;
+
+ int namelen = dentry-d_name.len PRAM_NAME_LEN ?
+ PRAM_NAME_LEN : dentry-d_name.len;
+
+ pidir = pram_get_inode(dir-i_sb, dir-i_ino);
+ pi = pram_get_inode(dir-i_sb, inode-i_ino);
+
+ dir-i_mtime = dir-i_ctime = CURRENT_TIME;
+
+ tail_ino = be64_to_cpu(pidir-i_type.dir.tail);
+ if (tail_ino != 0) {
+ pitail = pram_get_inode(dir-i_sb, tail_ino);
+ pram_memunlock_inode(pitail);
+ pitail-i_d.d_next = cpu_to_be64(inode-i_ino);
+ pram_memlock_inode(pitail);
+
+ prev_ino = tail_ino;
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = cpu_to_be64(inode-i_ino);
+ pidir-i_mtime = cpu_to_be32(dir-i_mtime.tv_sec);
+ pidir-i_ctime = cpu_to_be32(dir-i_ctime.tv_sec);
+ pram_memlock_inode(pidir);
+ } else {
+ /* the directory is empty */
+ prev_ino = 0;
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = cpu_to_be64(inode-i_ino);
+ pidir-i_type.dir.head = cpu_to_be64(inode-i_ino);
+ pidir-i_mtime = cpu_to_be32(dir-i_mtime.tv_sec);
+ pidir-i_ctime = cpu_to_be32(dir-i_ctime.tv_sec);
+ pram_memlock_inode(pidir);
+ }
+
+
+ pram_memunlock_inode(pi);
+ pi-i_d.d_prev = cpu_to_be64(prev_ino);
+ pi-i_d.d_parent = cpu_to_be64(dir-i_ino);
+ memcpy(pi-i_d.d_name, name, namelen);
+ pi-i_d.d_name[namelen] = '\0';
+ pram_memlock_inode(pi);
+ return 0;
+}
+
+int pram_remove_link(struct inode *inode)
+{
+ struct super_block *sb = inode-i_sb;
+ struct pram_inode *prev = NULL;
+ struct pram_inode *next = NULL;
+ struct pram_inode *pidir, *pi;
+
+ pi = pram_get_inode(sb, inode-i_ino);
+ pidir = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_parent));
+ if (!pidir)
+ return -EACCES;
+
+ if (inode-i_ino == be64_to_cpu(pidir-i_type.dir.head)) {
+ /* first inode in directory */
+ next = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_next));
+
+ if (next) {
+ pram_memunlock_inode(next);
+ next-i_d.d_prev = 0;
+ pram_memlock_inode(next);
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.head = pi-i_d.d_next;
+ } else {
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.head = 0;
+ pidir-i_type.dir.tail = 0;
+ }
+ pram_memlock_inode(pidir);
+ } else if (inode-i_ino == be64_to_cpu(pidir-i_type.dir.tail)) {
+ /* last inode in directory */
+ prev = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_prev));
+
+ pram_memunlock_inode(prev);
+ prev-i_d.d_next = 0;
+ pram_memlock_inode(prev);
+
+ pram_memunlock_inode(pidir);
+ pidir-i_type.dir.tail = pi-i_d.d_prev;
+ pram_memlock_inode(pidir);
+ } else {
+ /* somewhere in the middle */
+ prev = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_prev));
+ next = pram_get_inode(sb, be64_to_cpu(pi-i_d.d_next));
+
+ if (prev next) {
+ pram_memunlock_inode(prev);
+ prev-i_d.d_next = pi-i_d.d_next;
+ pram_memlock_inode(prev);
+
+ pram_memunlock_inode(next);
+ next-i_d.d_prev = pi-i_d.d_prev
[PATCH 12/16] pramfs: extended attributes
From: Marco Stornelli marco.storne...@gmail.com
Extended attributes operations.
Signed-off-by: Marco Stornelli marco.storne...@gmail.com
---
diff -Nurp linux-2.6.36-orig/fs/pramfs/xattr.c linux-2.6.36/fs/pramfs/xattr.c
--- linux-2.6.36-orig/fs/pramfs/xattr.c 1970-01-01 01:00:00.0 +0100
+++ linux-2.6.36/fs/pramfs/xattr.c 2010-09-14 19:45:40.0 +0200
@@ -0,0 +1,1108 @@
+/*
+ * FILE NAME fs/pramfs/xattr.c
+ *
+ * BRIEF DESCRIPTION
+ *
+ * Extended attributes operations.
+ *
+ * Copyright 2010 Marco Stornelli marco.storne...@gmail.com
+ *
+ * based on fs/ext2/xattr.c with the following copyright:
+ *
+ * Fix by Harrison Xing harri...@mountainviewdata.com.
+ * Extended attributes for symlinks and special files added per
+ * suggestion of Luka Renko luka.re...@hermes.si.
+ * xattr consolidation Copyright (c) 2004 James Morris jmor...@redhat.com,
+ * Red Hat Inc.
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed as is without any
+ * warranty of any kind, whether express or implied.
+ */
+
+/*
+ * Extended attributes are stored in blocks allocated outside of
+ * any inode. The i_xattr field is then made to point to this allocated
+ * block. If all extended attributes of an inode are identical, these
+ * inodes may share the same extended attribute block. Such situations
+ * are automatically detected by keeping a cache of recent attribute block
+ * numbers and hashes over the block's contents in memory.
+ *
+ *
+ * Extended attribute block layout:
+ *
+ * +--+
+ * | header |
+ * | entry 1 | |
+ * | entry 2 | | growing downwards
+ * | entry 3 | v
+ * | four null bytes |
+ * | . . .|
+ * | value 1 | ^
+ * | value 3 | | growing upwards
+ * | value 2 | |
+ * +--+
+ *
+ * The block header is followed by multiple entry descriptors. These entry
+ * descriptors are variable in size, and alligned to PRAM_XATTR_PAD
+ * byte boundaries. The entry descriptors are sorted by attribute name,
+ * so that two extended attribute blocks can be compared efficiently.
+ *
+ * Attribute values are aligned to the end of the block, stored in
+ * no specific order. They are also padded to PRAM_XATTR_PAD byte
+ * boundaries. No additional gaps are left between them.
+ *
+ * Locking strategy
+ *
+ * pi-i_xattr is protected by PRAM_I(inode)-xattr_sem.
+ * EA blocks are only changed if they are exclusive to an inode, so
+ * holding xattr_sem also means that nothing but the EA block's reference
+ * count will change. Multiple writers to an EA block are synchronized
+ * by the mutex in each block descriptor. Block descriptors are kept in a
+ * red black tree and the key is the absolute block number.
+ */
+
+#include linux/module.h
+#include linux/init.h
+#include linux/mbcache.h
+#include linux/rwsem.h
+#include linux/security.h
+#include pram.h
+#include xattr.h
+#include acl.h
+#include desctree.h
+
+#define HDR(bp) ((struct pram_xattr_header *)(bp))
+#define ENTRY(ptr) ((struct pram_xattr_entry *)(ptr))
+#define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1)
+#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
+#define GET_DESC(sbi, blocknr) lookup_xblock_desc(sbi, blocknr,
pram_xblock_desc_cache, 1)
+#define LOOKUP_DESC(sbi, blocknr) lookup_xblock_desc(sbi, blocknr, NULL, 0)
+
+#ifdef PRAM_XATTR_DEBUG
+# define ea_idebug(inode, f...) do { \
+ printk(KERN_DEBUG inode %ld: , inode-i_ino); \
+ printk(f); \
+ printk(\n); \
+ } while (0)
+# define ea_bdebug(blocknr, f...) do { \
+ printk(KERN_DEBUG block %lu: , blocknr); \
+ printk(f); \
+ printk(\n); \
+ } while (0)
+#else
+# define ea_idebug(f...)
+# define ea_bdebug(f...)
+#endif
+
+static int pram_xattr_set2(struct inode *, char *, struct pram_xblock_desc *,
struct pram_xattr_header *);
+
+static int pram_xattr_cache_insert(struct super_block *sb, unsigned long
blocknr, u32 xhash);
+static struct pram_xblock_desc *pram_xattr_cache_find(struct inode *,
+struct pram_xattr_header *);
+static void pram_xattr_rehash(struct pram_xattr_header *,
+ struct pram_xattr_entry *);
+
+static struct mb_cache *pram_xattr_cache;
+static struct kmem_cache *pram_xblock_desc_cache;
+
+static const struct xattr_handler *pram_xattr_handler_map[] = {
+ [PRAM_XATTR_INDEX_USER] = pram_xattr_user_handler,
+#ifdef CONFIG_PRAMFS_POSIX_ACL
+ [PRAM_XATTR_INDEX_POSIX_ACL_ACCESS] = pram_xattr_acl_access_handler,
+ [PRAM_XATTR_INDEX_POSIX_ACL_DEFAULT] = pram_xattr_acl_default_handler,
+#endif
+ [PRAM_XATTR_INDEX_TRUSTED] = pram_xattr_trusted_handler,
+#ifdef CONFIG_PRAMFS_SECURITY
+ [PRAM_XATTR_INDEX_SECURITY] = pram_xattr_security_handler,
+#endif
+};
+
+const
