PPM latest snapshots

Here are snapshots of the latest features in the Puppy Package Manager. The first shows the "Find" box on the main window. This will accept part-names and wildcards:



The dependencies window now has a "View hierarchy" button:



Here is the updated web page that introduces PPM:

http://puppylinux.com/woof/ppm.htm


Posted on 30 Mar 2009, 16:52


Comments:

Posted on 30 Mar 2009, 22:20 by Kirk
64bit
Barry,

Does Wolf support 64bit builds? Ubuntu, Arch, and Debian have them available. I don't have any 64bit hardware yet, but maybe soon.

PS: The wolf project is really looking brilliant.




Posted on 30 Mar 2009, 23:36 by kirk
pup_save
Barry,

Wow, this looks interesting. Enlarge a loopback block device without unmounting. You would also need to use a file system that can grow without umounting, like XFS. Might be very good for Woof when installing packages with lots of dependencies.

http://aufs.sourceforge.net/logrow.txt


Posted on 31 Mar 2009, 3:02 by happypuppy
Wolf? LOL
Wolf? LOL

It's woof :)

woof woof!




Posted on 31 Mar 2009, 6:24 by kirk
pup_save
Sorry, yes it's woof. I did get it right the second time. :)

My other mistake was implying that a change to XFS was needed for resizing. Looks like ext3 can do that. Here's part of the resize2fs man page:

"The resize2fs program will resize ext2 or ext3 file systems. It can be used to enlarge or shrink an unmounted file system located on device. If the filesystem is mounted, it can be used to expand the size of the mounted filesystem, assuming the kernel supports on-line resizing. (As of this writing, the Linux 2.6 kernel supports on-line resize for filesystems mounted using ext3 only.)"

I tried applying the logrow-2.6.27.patch (part of the AUFS1 package) to my Fatdog 2.6.28.6 kernel source, but it failed. I'll try manually applying it later.

PS: Information about AUFS2 can be found at http://aufs.sourceforge.net/README.aufs2 you'll have to use git to get a copy. The logrow stuff is part of the AUFS1 package.

.


Posted on 31 Mar 2009, 23:55 by kirk
pup_save
I did manage to get logrow working, sort of.

I can expand the size of a loop mounted block device with logrow and then use resize2fs to online resize the ext3 filesystem inside. As long as it's not a branch of AUFS. When I tried to do this with my pup_save file, the system became unstable, no messages were logged, and CPU usage went to 100%. I've sent an email to the AUFS mail list to see if anyone has had success using logrow with a RW AUFS branch.

If it does not work with AUFS it still may be better than using dd to make a bigger pup_save file. I haven't tried it with cryptoloop yet. Also, I had to compile the latest version of e2fsprogs to get resize2fs to work.

If you want to try it, you'll need to download AUFS1 from CVS to get the logrow source. The included kernel patch is for 2.6.27 and won't work for 2.6.28. I found a patch Junjiro Okajima had posted on lkml that does work:


Posted on 31 Mar 2009, 23:57 by kirk
pup_save
drivers/block/loop.c | 26 ++++++++++++++++++++++++++
include/linux/loop.h | 1 +
2 files changed, 27 insertions(+), 0 deletions(-)

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 5c4ee70..a034bf9 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -1137,6 +1137,28 @@ loop_get_status64(struct loop_device *lo, struct loop_info64 __user *arg) {
return err;
}

+static int loop_set_capacity(struct loop_device *lo, struct block_device *bdev)
+{
+ int err;
+ sector_t sec;
+ loff_t sz;
+
+ err = -ENXIO;
+ if (unlikely(lo->lo_state != Lo_bound))
+ goto out;
+ err = figure_loop_size(lo);
+ if (unlikely(err))
+ goto out;
+ sec = get_capacity(lo->lo_disk);
+ sz = sec << 9;
+ mutex_lock(&bdev->bd_mutex);
+ bd_set_size(bdev, sz);
+ mutex_unlock(&bdev->bd_mutex);
+
+ out:
+ return err;
+}
+
static int lo_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg)
{
@@ -1166,6 +1188,9 @@ static int lo_ioctl(struct block_device *bdev, fmode_t mode,
case LOOP_GET_STATUS64:
err = loop_get_status64(lo, (struct loop_info64 __user *) arg);
break;
+ case LOOP_SET_CAPACITY:
+ err = loop_set_capacity(lo, bdev);
+ break;
default:
err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL;
}
@@ -1311,6 +1336,7 @@ static int lo_compat_ioctl(struct block_device *bdev, fmode_t mode,
lo, (struct compat_loop_info __user *) arg);
mutex_unlock(&lo->lo_ctl_mutex);
break;
+ case LOOP_SET_CAPACITY:
case LOOP_CLR_FD:
case LOOP_GET_STATUS64:
case LOOP_SET_STATUS64:
diff --git a/include/linux/loop.h b/include/linux/loop.h
index 46169a7..e9e002a 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -160,5 +160,6 @@ int loop_unregister_transfer(int number);
#define LOOP_SET_STATUS64 0x4C04
#define LOOP_GET_STATUS64 0x4C05
#define LOOP_CHANGE_FD 0x4C06
+#define LOOP_SET_CAPACITY 0x4C07

#endif
--
--


Posted on 32 Mar 2009, 2:12 by kirk
pup_save
Tested with cryptoloop, no problem.

# dd if=/dev/zero of=./test.img count=32k
# losetup-FULL -e aes /dev/loop6 ./test.img
# mkfs -t ext3 /dev/loop6
# mount -t ext3 /dev/loop6 /mnt/data
# logrow -s 20000000 /dev/loop6 ./test.img (this grows the block device from 16MB to 20MB)
# resize2fs /dev/loop6