[kernel] r11916 - in dists/trunk/linux-2.6/debian: . patches/debian patches/series
Bastian Blank
waldi at alioth.debian.org
Tue Jul 29 11:53:39 UTC 2008
Author: waldi
Date: Tue Jul 29 11:53:38 2008
New Revision: 11916
Log:
* debian/changelog: Update.
* debian/patches/debian/include-userspace-compat.patch: Add.
* debian/patches/series/1~experimental.1: Add new patch.
Added:
dists/trunk/linux-2.6/debian/patches/debian/include-userspace-compat.patch
Modified:
dists/trunk/linux-2.6/debian/changelog
dists/trunk/linux-2.6/debian/patches/series/1~experimental.1
Modified: dists/trunk/linux-2.6/debian/changelog
==============================================================================
--- dists/trunk/linux-2.6/debian/changelog (original)
+++ dists/trunk/linux-2.6/debian/changelog Tue Jul 29 11:53:38 2008
@@ -138,6 +138,7 @@
* Export symbol required for MOL again. (closes: #460667)
* [powerpc/powerpc64] Fix console selection in LPAR environment.
(closes: #492703)
+ * Fix several userspace compatibility problems.
[ Christian T. Steigies ]
* [m68k] enable SERIAL_CONSOLE for amiga and atari
Added: dists/trunk/linux-2.6/debian/patches/debian/include-userspace-compat.patch
==============================================================================
--- (empty file)
+++ dists/trunk/linux-2.6/debian/patches/debian/include-userspace-compat.patch Tue Jul 29 11:53:38 2008
@@ -0,0 +1,643 @@
+diff --git a/include/asm-x86/vm86.h b/include/asm-x86/vm86.h
+index 074b357..dc7b4bc 100644
+--- a/include/asm-x86/vm86.h
++++ b/include/asm-x86/vm86.h
+@@ -20,6 +20,18 @@
+ #define X86_VM_MASK 0 /* No VM86 support */
+ #endif
+
++#ifndef __KERNEL__
++#define TF_MASK X86_EFLAGS_TF
++#define IF_MASK X86_EFLAGS_IF
++#define IOPL_MASK X86_EFLAGS_IOPL
++#define NT_MASK X86_EFLAGS_NT
++#define VM_MASK X86_VM_MASK
++#define AC_MASK X86_EFLAGS_AC
++#define VIF_MASK X86_EFLAGS_VIF
++#define VIP_MASK X86_EFLAGS_VIP
++#define ID_MASK X86_EFLAGS_ID
++#endif
++
+ #define BIOSSEG 0x0f000
+
+ #define CPU_086 0
+diff --git a/include/linux/Kbuild b/include/linux/Kbuild
+index 71d70d1..c134cb4 100644
+--- a/include/linux/Kbuild
++++ b/include/linux/Kbuild
+@@ -363,3 +363,7 @@ unifdef-y += xattr.h
+ unifdef-y += xfrm.h
+
+ objhdr-y += version.h
++
++# compatibility
++header-y += hdsmart.h
++header-y += lock_dlm_plock.h
+diff --git a/include/linux/hdsmart.h b/include/linux/hdsmart.h
+new file mode 100644
+index 0000000..7974a47
+--- /dev/null
++++ b/include/linux/hdsmart.h
+@@ -0,0 +1,124 @@
++/*
++ * linux/include/linux/hdsmart.h
++ *
++ * Copyright (C) 1999-2000 Michael Cornwell <cornwell at acm.org>
++ * Copyright (C) 2000 Andre Hedrick <andre at linux-ide.org>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2, or (at your option)
++ * any later version.
++ *
++ * You should have received a copy of the GNU General Public License
++ * (for example /usr/src/linux/COPYING); if not, write to the Free
++ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++#ifndef _LINUX_HDSMART_H
++#define _LINUX_HDSMART_H
++
++#define OFFLINE_FULL_SCAN 0
++#define SHORT_SELF_TEST 1
++#define EXTEND_SELF_TEST 2
++#define SHORT_CAPTIVE_SELF_TEST 129
++#define EXTEND_CAPTIVE_SELF_TEST 130
++
++/* smart_attribute is the vendor specific in SFF-8035 spec */
++typedef struct ata_smart_attribute_s {
++ unsigned char id;
++ unsigned short status_flag;
++ unsigned char normalized;
++ unsigned char worse_normal;
++ unsigned char raw[6];
++ unsigned char reserv;
++} __attribute__ ((packed)) ata_smart_attribute_t;
++
++/* smart_values is format of the read drive Atrribute command */
++typedef struct ata_smart_values_s {
++ unsigned short revnumber;
++ ata_smart_attribute_t vendor_attributes [30];
++ unsigned char offline_data_collection_status;
++ unsigned char self_test_exec_status;
++ unsigned short total_time_to_complete_off_line;
++ unsigned char vendor_specific_366;
++ unsigned char offline_data_collection_capability;
++ unsigned short smart_capability;
++ unsigned char errorlog_capability;
++ unsigned char vendor_specific_371;
++ unsigned char short_test_completion_time;
++ unsigned char extend_test_completion_time;
++ unsigned char reserved_374_385 [12];
++ unsigned char vendor_specific_386_509 [125];
++ unsigned char chksum;
++} __attribute__ ((packed)) ata_smart_values_t;
++
++/* Smart Threshold data structures */
++/* Vendor attribute of SMART Threshold */
++typedef struct ata_smart_threshold_entry_s {
++ unsigned char id;
++ unsigned char normalized_threshold;
++ unsigned char reserved[10];
++} __attribute__ ((packed)) ata_smart_threshold_entry_t;
++
++/* Format of Read SMART THreshold Command */
++typedef struct ata_smart_thresholds_s {
++ unsigned short revnumber;
++ ata_smart_threshold_entry_t thres_entries[30];
++ unsigned char reserved[149];
++ unsigned char chksum;
++} __attribute__ ((packed)) ata_smart_thresholds_t;
++
++typedef struct ata_smart_errorlog_command_struct_s {
++ unsigned char devicecontrolreg;
++ unsigned char featuresreg;
++ unsigned char sector_count;
++ unsigned char sector_number;
++ unsigned char cylinder_low;
++ unsigned char cylinder_high;
++ unsigned char drive_head;
++ unsigned char commandreg;
++ unsigned int timestamp;
++} __attribute__ ((packed)) ata_smart_errorlog_command_struct_t;
++
++typedef struct ata_smart_errorlog_error_struct_s {
++ unsigned char error_condition;
++ unsigned char extended_error[14];
++ unsigned char state;
++ unsigned short timestamp;
++} __attribute__ ((packed)) ata_smart_errorlog_error_struct_t;
++
++typedef struct ata_smart_errorlog_struct_s {
++ ata_smart_errorlog_command_struct_t commands[6];
++ ata_smart_errorlog_error_struct_t error_struct;
++} __attribute__ ((packed)) ata_smart_errorlog_struct_t;
++
++typedef struct ata_smart_errorlog_s {
++ unsigned char revnumber;
++ unsigned char error_log_pointer;
++ ata_smart_errorlog_struct_t errorlog_struct[5];
++ unsigned short ata_error_count;
++ unsigned short non_fatal_count;
++ unsigned short drive_timeout_count;
++ unsigned char reserved[53];
++ unsigned char chksum;
++} __attribute__ ((packed)) ata_smart_errorlog_t;
++
++typedef struct ata_smart_selftestlog_struct_s {
++ unsigned char selftestnumber;
++ unsigned char selfteststatus;
++ unsigned short timestamp;
++ unsigned char selftestfailurecheckpoint;
++ unsigned int lbafirstfailure;
++ unsigned char vendorspecific[15];
++} __attribute__ ((packed)) ata_smart_selftestlog_struct_t;
++
++typedef struct ata_smart_selftestlog_s {
++ unsigned short revnumber;
++ ata_smart_selftestlog_struct_t selftest_struct[21];
++ unsigned char vendorspecific[2];
++ unsigned char mostrecenttest;
++ unsigned char resevered[2];
++ unsigned char chksum;
++} __attribute__ ((packed)) ata_smart_selftestlog_t;
++
++#endif /* _LINUX_HDSMART_H */
+diff --git a/include/linux/lock_dlm_plock.h b/include/linux/lock_dlm_plock.h
+new file mode 100644
+index 0000000..fc34151
+--- /dev/null
++++ b/include/linux/lock_dlm_plock.h
+@@ -0,0 +1,41 @@
++/*
++ * Copyright (C) 2005 Red Hat, Inc. All rights reserved.
++ *
++ * This copyrighted material is made available to anyone wishing to use,
++ * modify, copy, or redistribute it subject to the terms and conditions
++ * of the GNU General Public License v.2.
++ */
++
++#ifndef __LOCK_DLM_PLOCK_DOT_H__
++#define __LOCK_DLM_PLOCK_DOT_H__
++
++#define GDLM_PLOCK_MISC_NAME "lock_dlm_plock"
++
++#define GDLM_PLOCK_VERSION_MAJOR 1
++#define GDLM_PLOCK_VERSION_MINOR 1
++#define GDLM_PLOCK_VERSION_PATCH 0
++
++enum {
++ GDLM_PLOCK_OP_LOCK = 1,
++ GDLM_PLOCK_OP_UNLOCK,
++ GDLM_PLOCK_OP_GET,
++};
++
++struct gdlm_plock_info {
++ __u32 version[3];
++ __u8 optype;
++ __u8 ex;
++ __u8 wait;
++ __u8 pad;
++ __u32 pid;
++ __s32 nodeid;
++ __s32 rv;
++ __u32 fsid;
++ __u64 number;
++ __u64 start;
++ __u64 end;
++ __u64 owner;
++};
++
++#endif
++
+diff --git a/include/linux/meye.h b/include/linux/meye.h
+index 12010ac..cb63106 100644
+--- a/include/linux/meye.h
++++ b/include/linux/meye.h
+@@ -59,6 +59,7 @@ struct meye_params {
+ /* V4L2 private controls */
+ #define V4L2_CID_AGC V4L2_CID_PRIVATE_BASE
+ #define V4L2_CID_MEYE_SHARPNESS (V4L2_CID_PRIVATE_BASE + 1)
++#define V4L2_CID_SHARPNESS V4L2_CID_MEYE_SHARPNESS
+ #define V4L2_CID_PICTURE (V4L2_CID_PRIVATE_BASE + 2)
+ #define V4L2_CID_JPEGQUAL (V4L2_CID_PRIVATE_BASE + 3)
+ #define V4L2_CID_FRAMERATE (V4L2_CID_PRIVATE_BASE + 4)
+diff --git a/include/linux/msdos_fs.h b/include/linux/msdos_fs.h
+index 81cd36b..04b620a 100644
+--- a/include/linux/msdos_fs.h
++++ b/include/linux/msdos_fs.h
+@@ -57,6 +57,9 @@
+ #define MSDOS_DOT ". " /* ".", padded to MSDOS_NAME chars */
+ #define MSDOS_DOTDOT ".. " /* "..", padded to MSDOS_NAME chars */
+
++#ifndef __KERNEL__
++#define FAT_VALID_MEDIA(x) ((0xF8 <= (x) && (x) <= 0xFF) || (x) == 0xF0)
++#endif
+ #define FAT_FIRST_ENT(s, x) ((MSDOS_SB(s)->fat_bits == 32 ? 0x0FFFFF00 : \
+ MSDOS_SB(s)->fat_bits == 16 ? 0xFF00 : 0xF00) | (x))
+
+diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
+index 25f8710..edd70d2 100644
+--- a/include/linux/netdevice.h
++++ b/include/linux/netdevice.h
+@@ -116,7 +116,10 @@ struct wireless_dev;
+ #define MAX_HEADER (LL_MAX_HEADER + 48)
+ #endif
+
+-#endif /* __KERNEL__ */
++#else /* __KERNEL__ */
++#define LL_MAX_HEADER 128
++#define MAX_HEADER (LL_MAX_HEADER + 48)
++#endif /* !__KERNEL__ */
+
+ struct net_device_subqueue
+ {
+diff --git a/include/mtd/Kbuild b/include/mtd/Kbuild
+index 8eb018f..84b7424 100644
+--- a/include/mtd/Kbuild
++++ b/include/mtd/Kbuild
+@@ -4,3 +4,6 @@ header-y += mtd-abi.h
+ header-y += mtd-user.h
+ header-y += nftl-user.h
+ header-y += ubi-user.h
++
++# compatibility
++header-y += ubi-header.h
+diff --git a/include/mtd/ubi-header.h b/include/mtd/ubi-header.h
+new file mode 100644
+index 0000000..292f916
+--- /dev/null
++++ b/include/mtd/ubi-header.h
+@@ -0,0 +1,372 @@
++/*
++ * Copyright (c) International Business Machines Corp., 2006
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
++ * the GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ * Authors: Artem Bityutskiy (Битюцкий Артём)
++ * Thomas Gleixner
++ * Frank Haverkamp
++ * Oliver Lohmann
++ * Andreas Arnez
++ */
++
++/*
++ * This file defines the layout of UBI headers and all the other UBI on-flash
++ * data structures. May be included by user-space.
++ */
++
++#ifndef __UBI_HEADER_H__
++#define __UBI_HEADER_H__
++
++#include <asm/byteorder.h>
++
++/* The version of UBI images supported by this implementation */
++#define UBI_VERSION 1
++
++/* The highest erase counter value supported by this implementation */
++#define UBI_MAX_ERASECOUNTER 0x7FFFFFFF
++
++/* The initial CRC32 value used when calculating CRC checksums */
++#define UBI_CRC32_INIT 0xFFFFFFFFU
++
++/* Erase counter header magic number (ASCII "UBI#") */
++#define UBI_EC_HDR_MAGIC 0x55424923
++/* Volume identifier header magic number (ASCII "UBI!") */
++#define UBI_VID_HDR_MAGIC 0x55424921
++
++/*
++ * Volume type constants used in the volume identifier header.
++ *
++ * @UBI_VID_DYNAMIC: dynamic volume
++ * @UBI_VID_STATIC: static volume
++ */
++enum {
++ UBI_VID_DYNAMIC = 1,
++ UBI_VID_STATIC = 2
++};
++
++/*
++ * Volume flags used in the volume table record.
++ *
++ * @UBI_VTBL_AUTORESIZE_FLG: auto-resize this volume
++ *
++ * %UBI_VTBL_AUTORESIZE_FLG flag can be set only for one volume in the volume
++ * table. UBI automatically re-sizes the volume which has this flag and makes
++ * the volume to be of largest possible size. This means that if after the
++ * initialization UBI finds out that there are available physical eraseblocks
++ * present on the device, it automatically appends all of them to the volume
++ * (the physical eraseblocks reserved for bad eraseblocks handling and other
++ * reserved physical eraseblocks are not taken). So, if there is a volume with
++ * the %UBI_VTBL_AUTORESIZE_FLG flag set, the amount of available logical
++ * eraseblocks will be zero after UBI is loaded, because all of them will be
++ * reserved for this volume. Note, the %UBI_VTBL_AUTORESIZE_FLG bit is cleared
++ * after the volume had been initialized.
++ *
++ * The auto-resize feature is useful for device production purposes. For
++ * example, different NAND flash chips may have different amount of initial bad
++ * eraseblocks, depending of particular chip instance. Manufacturers of NAND
++ * chips usually guarantee that the amount of initial bad eraseblocks does not
++ * exceed certain percent, e.g. 2%. When one creates an UBI image which will be
++ * flashed to the end devices in production, he does not know the exact amount
++ * of good physical eraseblocks the NAND chip on the device will have, but this
++ * number is required to calculate the volume sized and put them to the volume
++ * table of the UBI image. In this case, one of the volumes (e.g., the one
++ * which will store the root file system) is marked as "auto-resizable", and
++ * UBI will adjust its size on the first boot if needed.
++ *
++ * Note, first UBI reserves some amount of physical eraseblocks for bad
++ * eraseblock handling, and then re-sizes the volume, not vice-versa. This
++ * means that the pool of reserved physical eraseblocks will always be present.
++ */
++enum {
++ UBI_VTBL_AUTORESIZE_FLG = 0x01,
++};
++
++/*
++ * Compatibility constants used by internal volumes.
++ *
++ * @UBI_COMPAT_DELETE: delete this internal volume before anything is written
++ * to the flash
++ * @UBI_COMPAT_RO: attach this device in read-only mode
++ * @UBI_COMPAT_PRESERVE: preserve this internal volume - do not touch its
++ * physical eraseblocks, don't allow the wear-leveling unit to move them
++ * @UBI_COMPAT_REJECT: reject this UBI image
++ */
++enum {
++ UBI_COMPAT_DELETE = 1,
++ UBI_COMPAT_RO = 2,
++ UBI_COMPAT_PRESERVE = 4,
++ UBI_COMPAT_REJECT = 5
++};
++
++/* Sizes of UBI headers */
++#define UBI_EC_HDR_SIZE sizeof(struct ubi_ec_hdr)
++#define UBI_VID_HDR_SIZE sizeof(struct ubi_vid_hdr)
++
++/* Sizes of UBI headers without the ending CRC */
++#define UBI_EC_HDR_SIZE_CRC (UBI_EC_HDR_SIZE - sizeof(__be32))
++#define UBI_VID_HDR_SIZE_CRC (UBI_VID_HDR_SIZE - sizeof(__be32))
++
++/**
++ * struct ubi_ec_hdr - UBI erase counter header.
++ * @magic: erase counter header magic number (%UBI_EC_HDR_MAGIC)
++ * @version: version of UBI implementation which is supposed to accept this
++ * UBI image
++ * @padding1: reserved for future, zeroes
++ * @ec: the erase counter
++ * @vid_hdr_offset: where the VID header starts
++ * @data_offset: where the user data start
++ * @padding2: reserved for future, zeroes
++ * @hdr_crc: erase counter header CRC checksum
++ *
++ * The erase counter header takes 64 bytes and has a plenty of unused space for
++ * future usage. The unused fields are zeroed. The @version field is used to
++ * indicate the version of UBI implementation which is supposed to be able to
++ * work with this UBI image. If @version is greater then the current UBI
++ * version, the image is rejected. This may be useful in future if something
++ * is changed radically. This field is duplicated in the volume identifier
++ * header.
++ *
++ * The @vid_hdr_offset and @data_offset fields contain the offset of the the
++ * volume identifier header and user data, relative to the beginning of the
++ * physical eraseblock. These values have to be the same for all physical
++ * eraseblocks.
++ */
++struct ubi_ec_hdr {
++ __be32 magic;
++ __u8 version;
++ __u8 padding1[3];
++ __be64 ec; /* Warning: the current limit is 31-bit anyway! */
++ __be32 vid_hdr_offset;
++ __be32 data_offset;
++ __u8 padding2[36];
++ __be32 hdr_crc;
++} __attribute__ ((packed));
++
++/**
++ * struct ubi_vid_hdr - on-flash UBI volume identifier header.
++ * @magic: volume identifier header magic number (%UBI_VID_HDR_MAGIC)
++ * @version: UBI implementation version which is supposed to accept this UBI
++ * image (%UBI_VERSION)
++ * @vol_type: volume type (%UBI_VID_DYNAMIC or %UBI_VID_STATIC)
++ * @copy_flag: if this logical eraseblock was copied from another physical
++ * eraseblock (for wear-leveling reasons)
++ * @compat: compatibility of this volume (%0, %UBI_COMPAT_DELETE,
++ * %UBI_COMPAT_IGNORE, %UBI_COMPAT_PRESERVE, or %UBI_COMPAT_REJECT)
++ * @vol_id: ID of this volume
++ * @lnum: logical eraseblock number
++ * @leb_ver: version of this logical eraseblock (IMPORTANT: obsolete, to be
++ * removed, kept only for not breaking older UBI users)
++ * @data_size: how many bytes of data this logical eraseblock contains
++ * @used_ebs: total number of used logical eraseblocks in this volume
++ * @data_pad: how many bytes at the end of this physical eraseblock are not
++ * used
++ * @data_crc: CRC checksum of the data stored in this logical eraseblock
++ * @padding1: reserved for future, zeroes
++ * @sqnum: sequence number
++ * @padding2: reserved for future, zeroes
++ * @hdr_crc: volume identifier header CRC checksum
++ *
++ * The @sqnum is the value of the global sequence counter at the time when this
++ * VID header was created. The global sequence counter is incremented each time
++ * UBI writes a new VID header to the flash, i.e. when it maps a logical
++ * eraseblock to a new physical eraseblock. The global sequence counter is an
++ * unsigned 64-bit integer and we assume it never overflows. The @sqnum
++ * (sequence number) is used to distinguish between older and newer versions of
++ * logical eraseblocks.
++ *
++ * There are 2 situations when there may be more then one physical eraseblock
++ * corresponding to the same logical eraseblock, i.e., having the same @vol_id
++ * and @lnum values in the volume identifier header. Suppose we have a logical
++ * eraseblock L and it is mapped to the physical eraseblock P.
++ *
++ * 1. Because UBI may erase physical eraseblocks asynchronously, the following
++ * situation is possible: L is asynchronously erased, so P is scheduled for
++ * erasure, then L is written to,i.e. mapped to another physical eraseblock P1,
++ * so P1 is written to, then an unclean reboot happens. Result - there are 2
++ * physical eraseblocks P and P1 corresponding to the same logical eraseblock
++ * L. But P1 has greater sequence number, so UBI picks P1 when it attaches the
++ * flash.
++ *
++ * 2. From time to time UBI moves logical eraseblocks to other physical
++ * eraseblocks for wear-leveling reasons. If, for example, UBI moves L from P
++ * to P1, and an unclean reboot happens before P is physically erased, there
++ * are two physical eraseblocks P and P1 corresponding to L and UBI has to
++ * select one of them when the flash is attached. The @sqnum field says which
++ * PEB is the original (obviously P will have lower @sqnum) and the copy. But
++ * it is not enough to select the physical eraseblock with the higher sequence
++ * number, because the unclean reboot could have happen in the middle of the
++ * copying process, so the data in P is corrupted. It is also not enough to
++ * just select the physical eraseblock with lower sequence number, because the
++ * data there may be old (consider a case if more data was added to P1 after
++ * the copying). Moreover, the unclean reboot may happen when the erasure of P
++ * was just started, so it result in unstable P, which is "mostly" OK, but
++ * still has unstable bits.
++ *
++ * UBI uses the @copy_flag field to indicate that this logical eraseblock is a
++ * copy. UBI also calculates data CRC when the data is moved and stores it at
++ * the @data_crc field of the copy (P1). So when UBI needs to pick one physical
++ * eraseblock of two (P or P1), the @copy_flag of the newer one (P1) is
++ * examined. If it is cleared, the situation* is simple and the newer one is
++ * picked. If it is set, the data CRC of the copy (P1) is examined. If the CRC
++ * checksum is correct, this physical eraseblock is selected (P1). Otherwise
++ * the older one (P) is selected.
++ *
++ * Note, there is an obsolete @leb_ver field which was used instead of @sqnum
++ * in the past. But it is not used anymore and we keep it in order to be able
++ * to deal with old UBI images. It will be removed at some point.
++ *
++ * There are 2 sorts of volumes in UBI: user volumes and internal volumes.
++ * Internal volumes are not seen from outside and are used for various internal
++ * UBI purposes. In this implementation there is only one internal volume - the
++ * layout volume. Internal volumes are the main mechanism of UBI extensions.
++ * For example, in future one may introduce a journal internal volume. Internal
++ * volumes have their own reserved range of IDs.
++ *
++ * The @compat field is only used for internal volumes and contains the "degree
++ * of their compatibility". It is always zero for user volumes. This field
++ * provides a mechanism to introduce UBI extensions and to be still compatible
++ * with older UBI binaries. For example, if someone introduced a journal in
++ * future, he would probably use %UBI_COMPAT_DELETE compatibility for the
++ * journal volume. And in this case, older UBI binaries, which know nothing
++ * about the journal volume, would just delete this volume and work perfectly
++ * fine. This is similar to what Ext2fs does when it is fed by an Ext3fs image
++ * - it just ignores the Ext3fs journal.
++ *
++ * The @data_crc field contains the CRC checksum of the contents of the logical
++ * eraseblock if this is a static volume. In case of dynamic volumes, it does
++ * not contain the CRC checksum as a rule. The only exception is when the
++ * data of the physical eraseblock was moved by the wear-leveling unit, then
++ * the wear-leveling unit calculates the data CRC and stores it in the
++ * @data_crc field. And of course, the @copy_flag is %in this case.
++ *
++ * The @data_size field is used only for static volumes because UBI has to know
++ * how many bytes of data are stored in this eraseblock. For dynamic volumes,
++ * this field usually contains zero. The only exception is when the data of the
++ * physical eraseblock was moved to another physical eraseblock for
++ * wear-leveling reasons. In this case, UBI calculates CRC checksum of the
++ * contents and uses both @data_crc and @data_size fields. In this case, the
++ * @data_size field contains data size.
++ *
++ * The @used_ebs field is used only for static volumes and indicates how many
++ * eraseblocks the data of the volume takes. For dynamic volumes this field is
++ * not used and always contains zero.
++ *
++ * The @data_pad is calculated when volumes are created using the alignment
++ * parameter. So, effectively, the @data_pad field reduces the size of logical
++ * eraseblocks of this volume. This is very handy when one uses block-oriented
++ * software (say, cramfs) on top of the UBI volume.
++ */
++struct ubi_vid_hdr {
++ __be32 magic;
++ __u8 version;
++ __u8 vol_type;
++ __u8 copy_flag;
++ __u8 compat;
++ __be32 vol_id;
++ __be32 lnum;
++ __be32 leb_ver; /* obsolete, to be removed, don't use */
++ __be32 data_size;
++ __be32 used_ebs;
++ __be32 data_pad;
++ __be32 data_crc;
++ __u8 padding1[4];
++ __be64 sqnum;
++ __u8 padding2[12];
++ __be32 hdr_crc;
++} __attribute__ ((packed));
++
++/* Internal UBI volumes count */
++#define UBI_INT_VOL_COUNT 1
++
++/*
++ * Starting ID of internal volumes. There is reserved room for 4096 internal
++ * volumes.
++ */
++#define UBI_INTERNAL_VOL_START (0x7FFFFFFF - 4096)
++
++/* The layout volume contains the volume table */
++
++#define UBI_LAYOUT_VOLUME_ID UBI_INTERNAL_VOL_START
++#define UBI_LAYOUT_VOLUME_TYPE UBI_VID_DYNAMIC
++#define UBI_LAYOUT_VOLUME_ALIGN 1
++#define UBI_LAYOUT_VOLUME_EBS 2
++#define UBI_LAYOUT_VOLUME_NAME "layout volume"
++#define UBI_LAYOUT_VOLUME_COMPAT UBI_COMPAT_REJECT
++
++/* The maximum number of volumes per one UBI device */
++#define UBI_MAX_VOLUMES 128
++
++/* The maximum volume name length */
++#define UBI_VOL_NAME_MAX 127
++
++/* Size of the volume table record */
++#define UBI_VTBL_RECORD_SIZE sizeof(struct ubi_vtbl_record)
++
++/* Size of the volume table record without the ending CRC */
++#define UBI_VTBL_RECORD_SIZE_CRC (UBI_VTBL_RECORD_SIZE - sizeof(__be32))
++
++/**
++ * struct ubi_vtbl_record - a record in the volume table.
++ * @reserved_pebs: how many physical eraseblocks are reserved for this volume
++ * @alignment: volume alignment
++ * @data_pad: how many bytes are unused at the end of the each physical
++ * eraseblock to satisfy the requested alignment
++ * @vol_type: volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME)
++ * @upd_marker: if volume update was started but not finished
++ * @name_len: volume name length
++ * @name: the volume name
++ * @flags: volume flags (%UBI_VTBL_AUTORESIZE_FLG)
++ * @padding: reserved, zeroes
++ * @crc: a CRC32 checksum of the record
++ *
++ * The volume table records are stored in the volume table, which is stored in
++ * the layout volume. The layout volume consists of 2 logical eraseblock, each
++ * of which contains a copy of the volume table (i.e., the volume table is
++ * duplicated). The volume table is an array of &struct ubi_vtbl_record
++ * objects indexed by the volume ID.
++ *
++ * If the size of the logical eraseblock is large enough to fit
++ * %UBI_MAX_VOLUMES records, the volume table contains %UBI_MAX_VOLUMES
++ * records. Otherwise, it contains as many records as it can fit (i.e., size of
++ * logical eraseblock divided by sizeof(struct ubi_vtbl_record)).
++ *
++ * The @upd_marker flag is used to implement volume update. It is set to %1
++ * before update and set to %0 after the update. So if the update operation was
++ * interrupted, UBI knows that the volume is corrupted.
++ *
++ * The @alignment field is specified when the volume is created and cannot be
++ * later changed. It may be useful, for example, when a block-oriented file
++ * system works on top of UBI. The @data_pad field is calculated using the
++ * logical eraseblock size and @alignment. The alignment must be multiple to the
++ * minimal flash I/O unit. If @alignment is 1, all the available space of
++ * the physical eraseblocks is used.
++ *
++ * Empty records contain all zeroes and the CRC checksum of those zeroes.
++ */
++struct ubi_vtbl_record {
++ __be32 reserved_pebs;
++ __be32 alignment;
++ __be32 data_pad;
++ __u8 vol_type;
++ __u8 upd_marker;
++ __be16 name_len;
++ __u8 name[UBI_VOL_NAME_MAX+1];
++ __u8 flags;
++ __u8 padding[23];
++ __be32 crc;
++} __attribute__ ((packed));
++
++#endif /* !__UBI_HEADER_H__ */
Modified: dists/trunk/linux-2.6/debian/patches/series/1~experimental.1
==============================================================================
--- dists/trunk/linux-2.6/debian/patches/series/1~experimental.1 (original)
+++ dists/trunk/linux-2.6/debian/patches/series/1~experimental.1 Tue Jul 29 11:53:38 2008
@@ -1,4 +1,3 @@
-#+ bugfix/all/patch-2.6.26-rc6-git6
+ debian/version.patch
+ debian/kernelvariables.patch
+ debian/doc-build-parallel.patch
@@ -65,3 +64,4 @@
+ features/x86/drivers-hp_ilo.patch
+ bugfix/all/Input-i8042-add-Arima-Rioworks-HDAMB-board-to-nol.patch
+ bugfix/powerpc/lpar-console.patch
++ debian/include-userspace-compat.patch
More information about the Kernel-svn-changes
mailing list