Skip to content

L
linux
Commit bf291a02 authored by Martin Schwidefsky's avatar Martin Schwidefsky Committed by Linus Torvalds
Browse files
Options

[PATCH] 2.5.22: new xpram driver. 

seems someone else was faster fixing the hardsects problem in the xpram
driver.  We continued with my new version of the xpram driver.  Arnd
Bergmann found some bugs and added support for the driverfs.
parent 144d6034
Show whitespace changes
Inline Side-by-side
Showing with 373 additions and 992 deletions
drivers/s390/block/xpram.c
View file @ bf291a02
/* /*
* Xpram.c -- the S/390 expanded memory RAM-disk * Xpram.c -- the S/390 expanded memory RAM-disk
* *
...@@ -8,14 +7,11 @@ ...@@ -8,14 +7,11 @@
* *
* Author of XPRAM specific coding: Reinhard Buendgen * Author of XPRAM specific coding: Reinhard Buendgen
* buendgen@de.ibm.com * buendgen@de.ibm.com
* Rewrite for 2.5: Martin Schwidefsky <schwidefsky@de.ibm.com>
* *
* External interfaces: * External interfaces:
* Interfaces to linux kernel * Interfaces to linux kernel
* xpram_setup: read kernel parameters (see init/main.c) * xpram_setup: read kernel parameters
* xpram_init: initialize device driver (see drivers/block/ll_rw_blk.c)
* Module interfaces
* init_module
* cleanup_module
* Device specific file operations * Device specific file operations
* xpram_iotcl * xpram_iotcl
* xpram_open * xpram_open
...@@ -26,119 +22,52 @@ ...@@ -26,119 +22,52 @@
* (with different minors). The partitioning set up can be * (with different minors). The partitioning set up can be
* set by kernel or module parameters (int devs & int sizes[]) * set by kernel or module parameters (int devs & int sizes[])
* *
* module parameters: devs= and sizes=
* kernel parameters: xpram_parts=
* note: I did not succeed in parsing numbers
* for module parameters of type string "s" ?!?
*
* Other kenel files/modules affected(gerp for "xpram" or "XPRAM":
* drivers/s390/Config.in
* drivers/s390/block/Makefile
* include/linux/blk.h
* include/linux/major.h
* init/main.c
* drivers/block//ll_rw_blk.c
*
*
* Potential future improvements: * Potential future improvements:
* request clustering: first coding started not yet tested or integrated
* I doubt that it really pays off
* generic hard disk support to replace ad-hoc partitioning * generic hard disk support to replace ad-hoc partitioning
*
* Tested with 2.2.14 (under VM)
*/ */
#ifdef MODULE
# ifndef __KERNEL__
# define __KERNEL__
# endif
# define __NO_VERSION__ /* don't define kernel_version in module.h */
#endif /* MODULE */
#include <linux/module.h> #include <linux/module.h>
#include <linux/version.h> #include <linux/version.h>
#ifdef MODULE
char kernel_version [] = UTS_RELEASE;
#endif
#include <linux/config.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/devfs_fs_kernel.h>
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/timer.h>
#include <linux/types.h> /* size_t */
#include <linux/ctype.h> /* isdigit, isxdigit */ #include <linux/ctype.h> /* isdigit, isxdigit */
#include <linux/fcntl.h> /* O_ACCMODE */ #include <linux/errno.h>
#include <linux/hdreg.h> /* HDIO_GETGEO */ #include <linux/init.h>
#include <linux/slab.h>
#include <asm/system.h> /* cli(), *_flags */
#include <asm/uaccess.h> /* put_user */
#define MAJOR_NR xpram_major /* force definitions on in blk.h */
int xpram_major; /* must be declared before including blk.h */
devfs_handle_t xpram_devfs_handle;
#define DEVICE_NR(device) MINOR(device) /* xpram has no partition bits */
#define DEVICE_NO_RANDOM /* no entropy to contribute */
#define DEVICE_OFF(d) /* do-nothing */
#include <linux/blk.h> #include <linux/blk.h>
#include <linux/blkpg.h>
#include <linux/hdreg.h> /* HDIO_GETGEO */
#include <linux/device.h>
#include <asm/uaccess.h>
#include "xpram.h" /* local definitions */ #define XPRAM_NAME "xpram"
#define XPRAM_DEVS 1 /* one partition */
#define XPRAM_MAX_DEVS 32 /* maximal number of devices (partitions) */
__setup("xpram_parts=", xpram_setup); #define PRINT_DEBUG(x...) printk(KERN_DEBUG XPRAM_NAME " debug:" x)
#define PRINT_INFO(x...) printk(KERN_INFO XPRAM_NAME " info:" x)
#define PRINT_WARN(x...) printk(KERN_WARNING XPRAM_NAME " warning:" x)
#define PRINT_ERR(x...) printk(KERN_ERR XPRAM_NAME " error:" x)
/* static struct device xpram_sys_device = {
define the debug levels: name: "S/390 expanded memory RAM disk",
- 0 No debugging output to console or syslog bus_id: "xpram",
- 1 Log internal errors to syslog, ignore check conditions };
- 2 Log internal errors and check conditions to syslog
- 3 Log internal errors to console, log check conditions to syslog
- 4 Log internal errors and check conditions to console
- 5 panic on internal errors, log check conditions to console
- 6 panic on both, internal errors and check conditions
*/
#define XPRAM_DEBUG 4
#define PRINTK_HEADER XPRAM_NAME typedef struct {
unsigned long size; /* size of xpram segment in pages */
unsigned long offset; /* start page of xpram segment */
} xpram_device_t;
#if XPRAM_DEBUG > 0 static xpram_device_t xpram_devices[XPRAM_MAX_DEVS];
#define PRINT_DEBUG(x...) printk ( KERN_DEBUG PRINTK_HEADER "debug:" x ) static int xpram_sizes[XPRAM_MAX_DEVS];
#define PRINT_INFO(x...) printk ( KERN_INFO PRINTK_HEADER "info:" x ) static unsigned long xpram_pages;
#define PRINT_WARN(x...) printk ( KERN_WARNING PRINTK_HEADER "warning:" x ) static int xpram_devs;
#define PRINT_ERR(x...) printk ( KERN_ERR PRINTK_HEADER "error:" x ) static devfs_handle_t xpram_devfs_handle;
#define PRINT_FATAL(x...) panic ( PRINTK_HEADER "panic:"x )
#else
#define PRINT_DEBUG(x...) printk ( KERN_DEBUG PRINTK_HEADER "debug:" x )
#define PRINT_INFO(x...) printk ( KERN_DEBUG PRINTK_HEADER "info:" x )
#define PRINT_WARN(x...) printk ( KERN_DEBUG PRINTK_HEADER "warning:" x )
#define PRINT_ERR(x...) printk ( KERN_DEBUG PRINTK_HEADER "error:" x )
#define PRINT_FATAL(x...) printk ( KERN_DEBUG PRINTK_HEADER "panic:" x )
#endif
/* /*
* Non-prefixed symbols are static. They are meant to be assigned at * Parameter parsing functions.
* load time. Prefixed symbols are not static, so they can be used in
* debugging. They are hidden anyways by register_symtab() unless
* XPRAM_DEBUG is defined.
*/ */
static int major = XPRAM_MAJOR;
static int devs = XPRAM_DEVS; static int devs = XPRAM_DEVS;
static int sizes[XPRAM_MAX_DEVS] = { 0, }; static unsigned long sizes[XPRAM_MAX_DEVS];
static int blksize = XPRAM_BLKSIZE;
static int hardsect = XPRAM_HARDSECT;
int xpram_devs;
int xpram_blksize, xpram_hardsect;
int xpram_mem_avail = 0;
unsigned long xpram_sizes[XPRAM_MAX_DEVS];
MODULE_PARM(devs,"i"); MODULE_PARM(devs,"i");
MODULE_PARM(sizes,"1-" __MODULE_STRING(XPRAM_MAX_DEVS) "i"); MODULE_PARM(sizes,"1-" __MODULE_STRING(XPRAM_MAX_DEVS) "i");
...@@ -150,512 +79,301 @@ MODULE_PARM_DESC(sizes, "list of device (partition) sizes " \ ...@@ -150,512 +79,301 @@ MODULE_PARM_DESC(sizes, "list of device (partition) sizes " \
"All devices with size 0 equally partition the " "All devices with size 0 equally partition the "
"remaining space on the expanded strorage not " "remaining space on the expanded strorage not "
"claimed by explicit sizes\n"); "claimed by explicit sizes\n");
MODULE_LICENSE("GPL");
#ifndef MODULE
/* The following items are obtained through kmalloc() in init_module() */
Xpram_Dev *xpram_devices = NULL;
int *xpram_offsets = NULL; /* partition offsets */
#define MIN(x,y) ((x) < (y) ? (x) : (y))
#define MAX(x,y) ((x) > (y) ? (x) : (y))
/*
* compute nearest multiple of 4 , argument must be non-negative
* the macros used depends on XPRAM_KB_IN_PG = 4
*/
#define NEXT4(x) ((x & 0x3) ? (x+4-(x &0x3)) : (x)) /* increment if needed */
#define LAST4(x) ((x & 0x3) ? (x-4+(x & 0x3)) : (x)) /* decrement if needed */
#if 0 /* this is probably not faster than the previous code */
#define NEXT4(x) ((((x-1)>>2)>>2)+4) /* increment if needed */
#define LAST4(x) (((x+3)>>2)<<2) /* decrement if needed */
#endif
/* integer formats */
#define XPRAM_INVALF -1 /* invalid */
#define XPRAM_HEXF 0 /* hexadecimal */
#define XPRAM_DECF 1 /* decimal */
/* /*
* parsing operations (needed for kernel parameter parsing) * Parses the kernel parameters given in the kernel parameter line.
*/ * The expected format is
* <number_of_partitions>[","<partition_size>]*
/* ------------------------------------------------------------------------- * where
* sets the string pointer after the next comma * devices is a positive integer that initializes xpram_devs
* * each size is a non-negative integer possibly followed by a
* argument: strptr pointer to string * magnitude (k,K,m,M,g,G), the list of sizes initialises
* side effect: strptr points to endof string or to position of the next * xpram_sizes
* comma
* ------------------------------------------------------------------------*/
static void
xpram_scan_to_next_comma (char **strptr)
{
while ( ((**strptr) != ',') && (**strptr) )
(*strptr)++;
}
/* -------------------------------------------------------------------------
* interpret character as hex-digit
*
* argument: c charcter
* result: c interpreted as hex-digit
* note: can be used to read digits for any base <= 16
* ------------------------------------------------------------------------*/
static int
xpram_get_hexdigit (char c)
{
if ((c >= '0') && (c <= '9'))
return c - '0';
if ((c >= 'a') && (c <= 'f'))
return c + 10 - 'a';
if ((c >= 'A') && (c <= 'F'))
return c + 10 - 'A';
return -1;
}
/*--------------------------------------------------------------------------
* Check format of unsigned integer
*
* Argument: strptr pointer to string
* result: -1 if strptr does not start with a digit
* (does not start an integer)
* 0 if strptr starts a positive hex-integer with "0x"
* 1 if strptr start a positive decimal integer
*
* side effect: if strptr start a positive hex-integer then strptr is
* set to the character after the "0x"
*-------------------------------------------------------------------------*/
static int
xpram_int_format(char **strptr)
{
if ( !isdigit(**strptr) )
return XPRAM_INVALF;
if ( (**strptr == '0')
&& ( (*((*strptr)+1) == 'x') || (*((*strptr) +1) == 'X') )
&& isdigit(*((*strptr)+3)) ) {
*strptr=(*strptr)+2;
return XPRAM_HEXF;
} else return XPRAM_DECF;
}
/*--------------------------------------------------------------------------
* Read non-negative decimal integer
*
* Argument: strptr pointer to string starting with a non-negative integer
* in decimal format
* result: the value of theinitial integer pointed to by strptr
*
* side effect: strptr is set to the first character following the integer
*-------------------------------------------------------------------------*/
static int
xpram_read_decint (char ** strptr)
{
int res=0;
while ( isdigit(**strptr) ) {
res = (res*10) + xpram_get_hexdigit(**strptr);
(*strptr)++;
}
return res;
}
/*--------------------------------------------------------------------------
* Read non-negative hex-integer
*
* Argument: strptr pointer to string starting with a non-negative integer
* in hexformat (without "0x" prefix)
* result: the value of the initial integer pointed to by strptr
*
* side effect: strptr is set to the first character following the integer
*-------------------------------------------------------------------------*/
static int
xpram_read_hexint (char ** strptr)
{
int res=0;
while ( isxdigit(**strptr) ) {
res = (res<<4) + xpram_get_hexdigit(**strptr);
(*strptr)++;
}
return res;
}
/*--------------------------------------------------------------------------
* Read non-negative integer
*
* Argument: strptr pointer to string starting with a non-negative integer
(either in decimal- or in hex-format
* result: the value of the initial integer pointed to by strptr
* in case of a parsing error the result is -EINVAL
* *
* side effect: strptr is set to the first character following the integer * Arguments
*-------------------------------------------------------------------------*/ * str: substring of kernel parameter line that contains xprams
* kernel parameters.
static int
xpram_read_int (char ** strptr)
{
switch ( xpram_int_format(strptr) ) {
case XPRAM_INVALF: return -EINVAL;
case XPRAM_HEXF: return xpram_read_hexint(strptr);
case XPRAM_DECF: return xpram_read_decint(strptr);
default: return -EINVAL;
}
}
/*--------------------------------------------------------------------------
* Read size
* *
* Argument: strptr pointer to string starting with a non-negative integer * Result 0 on success, -EINVAL else -- only for Version > 2.3
* followed optionally by a size modifier:
* k or K for kilo (default),
* m or M for mega
* g or G for giga
* result: the value of the initial integer pointed to by strptr
* multiplied by the modifier value devided by 1024
* in case of a parsing error the result is -EINVAL
* *
* side effect: strptr is set to the first character following the size * Side effects
*-------------------------------------------------------------------------*/ * the global variabls devs is set to the value of
* <number_of_partitions> and sizes[i] is set to the i-th
static int * partition size (if provided). A parsing error of a value
xpram_read_size (char ** strptr) * results in this value being set to -EINVAL.
*/
static int __init xpram_setup (char *str)
{ {
int res; char *cp;
int i;
res=xpram_read_int(strptr);
if ( res < 0 )return res;
switch ( **strptr ) {
case 'g':
case 'G': res=res*1024;
case 'm':
case 'M': res=res*1024;
case 'k' :
case 'K' : (* strptr)++;
}
return res; devs = simple_strtoul(str, &cp, 10);
if (cp <= str || devs > XPRAM_MAX_DEVS)
return 0;
for (i = 0; (i < devs) && (*cp++ == ','); i++) {
sizes[i] = simple_strtoul(cp, &cp, 10);
if (*cp == 'g' || *cp == 'G') {
sizes[i] <<= 20;
cp++;
} else if (*cp == 'm' || *cp == 'M') {
sizes[i] <<= 10;
cp++;
} else if (*cp == 'k' || *cp == 'K')
cp++;
while (isspace(*cp)) cp++;
}
if (*cp == ',' && i >= devs)
PRINT_WARN("partition sizes list has too many entries.\n");
else if (*cp != 0)
PRINT_WARN("ignored '%s' at end of parameter string.\n", cp);
return 1;
} }
__setup("xpram_parts=", xpram_setup);
/*--------------------------------------------------------------------------
* Read tail of comma separated size list ",i1,i2,...,in"
*
* Arguments:strptr pointer to string. It is assumed that the string has
* the format (","<size>)*
* maxl integer describing the maximal number of elements in the
list pointed to by strptr, max must be > 0.
* ilist array of dimension >= maxl of integers to be modified
*
* result: -EINVAL if the list is longer than maxl
* 0 otherwise
*
* side effects: for j=1,...,n ilist[ij] is set to the value of ij if it is
* a valid non-negative integer and to -EINVAL otherwise
* if no comma is found where it is expected an entry in
* ilist is set to -EINVAL
*-------------------------------------------------------------------------*/
static int
xpram_read_size_list_tail (char ** strptr, int maxl, int * ilist)
{
int i=0;
char *str = *strptr;
int res=0;
while ( (*str == ',') && (i < maxl) ) {
str++;
ilist[i] = xpram_read_size(&str);
if ( ilist[i] == -EINVAL ) {
xpram_scan_to_next_comma(&str);
res = -EINVAL;
}
i++;
}
return res;
#if 0 /* be lenient about trailing stuff */
if ( *str != 0 && *str != ' ' ) {
ilist[MAX(i-1,0)] = -EINVAL;
return -EINVAL;
} else return 0;
#endif #endif
}
/* /*
* expanded memory operations * Copy expanded memory page (4kB) into main memory
* Arguments
* page_addr: address of target page
* xpage_index: index of expandeded memory page
* Return value
* 0: if operation succeeds
* -EIO: if pgin failed
* -ENXIO: if xpram has vanished
*/ */
static int xpram_page_in (unsigned long page_addr, unsigned long xpage_index)
/*--------------------------------------------------------------------*/
/* Copy expanded memory page (4kB) into main memory */
/* Arguments */
/* page_addr: address of target page */
/* xpage_index: index of expandeded memory page */
/* Return value */
/* 0: if operation succeeds */
/* non-0: otherwise */
/*--------------------------------------------------------------------*/
long xpram_page_in (unsigned long page_addr, unsigned long xpage_index)
{ {
int cc=0; int cc;
unsigned long real_page_addr = __pa(page_addr);
__asm__ __volatile(
" lhi %0,2\n" /* return unused cc 2 if pgin traps */
" .insn rre,0xb22e0000,%1,%2\n" /* pgin %1,%2 */
"0: ipm %0\n"
" srl %0,28\n"
"1:\n"
#ifndef CONFIG_ARCH_S390X #ifndef CONFIG_ARCH_S390X
__asm__ __volatile__ ( ".section __ex_table,\"a\"\n"
" lr 1,%1 \n" /* r1 = real_page_addr */ " .align 4\n"
" lr 2,%2 \n" /* r2 = xpage_index */ " .long 0b,1b\n"
" .long 0xb22e0012 \n" /* pgin r1,r2 */ ".previous"
/* copy page from expanded memory */ #else
"0: ipm %0 \n" /* save status (cc & program mask */ ".section __ex_table,\"a\"\n"
" srl %0,28 \n" /* cc into least significant bits */ " .align 8\n"
"1: \n" /* we are done */ " .quad 0b,1b\n"
".section .fixup,\"ax\"\n" /* start of fix up section */ ".previous"
"2: lhi %0,2 \n" /* return unused condition code 2 */ #endif
" bras 1,3f \n" /* safe label 1: in r1 and goto 3 */ : "=&d" (cc)
" .long 1b \n" /* literal containing label 1 */ : "a" (__pa(page_addr)), "a" (xpage_index)
"3: l 1,0(1) \n" /* load label 1 address into r1 */ : "cc" );
" br 1 \n" /* goto label 1 (across sections) */ if (cc == 3)
".previous \n" /* back in text section */ return -ENXIO;
".section __ex_table,\"a\"\n" /* start __extable */ if (cc == 2) {
" .align 4 \n" PRINT_ERR("expanded storage lost!\n");
" .long 0b,2b \n" /* failure point 0, fixup code 2 */ return -ENXIO;
".previous \n" }
: "=d" (cc) : "d" (real_page_addr), "d" (xpage_index) : "cc", "1", "2" if (cc == 1) {
); PRINT_ERR("page in failed for page index %ld.\n",
#else /* CONFIG_ARCH_S390X */ xpage_index);
__asm__ __volatile__ ( return -EIO;
" lgr 1,%1 \n" /* r1 = real_page_addr */ }
" lgr 2,%2 \n" /* r2 = xpage_index */ return 0;
" .long 0xb22e0012 \n" /* pgin r1,r2 */
/* copy page from expanded memory */
"0: ipm %0 \n" /* save status (cc & program mask */
" srl %0,28 \n" /* cc into least significant bits */
"1: \n" /* we are done */
".section .fixup,\"ax\"\n" /* start of fix up section */
"2: lghi %0,2 \n" /* return unused condition code 2 */
" jg 1b \n" /* goto label 1 above */
".previous \n" /* back in text section */
".section __ex_table,\"a\"\n" /* start __extable */
" .align 8 \n"
" .quad 0b,2b \n" /* failure point 0, fixup code 2 */
".previous \n"
: "=d" (cc) : "d" (real_page_addr), "d" (xpage_index) : "cc", "1", "2"
);
#endif /* CONFIG_ARCH_S390X */
switch (cc) {
case 0: return 0;
case 1: return -EIO;
case 2: return -ENXIO;
case 3: return -ENXIO;
default: return -EIO; /* should not happen */
};
} }
/*--------------------------------------------------------------------*/ /*
/* Copy a 4kB page of main memory to an expanded memory page */ * Copy a 4kB page of main memory to an expanded memory page
/* Arguments */ * Arguments
/* page_addr: address of source page */ * page_addr: address of source page
/* xpage_index: index of expandeded memory page */ * xpage_index: index of expandeded memory page
/* Return value */ * Return value
/* 0: if operation succeeds */ * 0: if operation succeeds
/* non-0: otherwise */ * -EIO: if pgout failed
/*--------------------------------------------------------------------*/ * -ENXIO: if xpram has vanished
long xpram_page_out (unsigned long page_addr, unsigned long xpage_index) */
static long xpram_page_out (unsigned long page_addr, unsigned long xpage_index)
{ {
int cc=0; int cc;
unsigned long real_page_addr = __pa(page_addr);
__asm__ __volatile(
" lhi %0,2\n" /* return unused cc 2 if pgout traps */
" .insn rre,0xb22f0000,%1,%2\n" /* pgout %1,%2 */
"0: ipm %0\n"
" srl %0,28\n"
"1:\n"
#ifndef CONFIG_ARCH_S390X #ifndef CONFIG_ARCH_S390X
__asm__ __volatile__ ( ".section __ex_table,\"a\"\n"
" lr 1,%1 \n" /* r1 = mem_page */ " .align 4\n"
" lr 2,%2 \n" /* r2 = rpi */ " .long 0b,1b\n"
" .long 0xb22f0012 \n" /* pgout r1,r2 */ ".previous"
/* copy page from expanded memory */ #else
"0: ipm %0 \n" /* save status (cc & program mask */ ".section __ex_table,\"a\"\n"
" srl %0,28 \n" /* cc into least significant bits */ " .align 8\n"
"1: \n" /* we are done */ " .quad 0b,1b\n"
".section .fixup,\"ax\"\n" /* start of fix up section */ ".previous"
"2: lhi %0,2 \n" /* return unused condition code 2 */ #endif
" bras 1,3f \n" /* safe label 1: in r1 and goto 3 */ : "=&d" (cc)
" .long 1b \n" /* literal containing label 1 */ : "a" (__pa(page_addr)), "a" (xpage_index)
"3: l 1,0(1) \n" /* load label 1 address into r1 */ : "cc" );
" br 1 \n" /* goto label 1 (across sections) */ if (cc == 3)
".previous \n" /* back in text section */ return -ENXIO;
".section __ex_table,\"a\"\n" /* start __extable */ if (cc == 2) {
" .align 4 \n" PRINT_ERR("expanded storage lost!\n");
" .long 0b,2b \n" /* failure point 0, fixup code 2 */ return -ENXIO;
".previous \n" }
: "=d" (cc) : "d" (real_page_addr), "d" (xpage_index) : "cc", "1", "2" if (cc == 1) {
); PRINT_ERR("page out failed for page index %ld.\n",
#else /* CONFIG_ARCH_S390X */ xpage_index);
__asm__ __volatile__ ( return -EIO;
" lgr 1,%1 \n" /* r1 = mem_page */
" lgr 2,%2 \n" /* r2 = rpi */
" .long 0xb22f0012 \n" /* pgout r1,r2 */
/* copy page from expanded memory */
"0: ipm %0 \n" /* save status (cc & program mask */
" srl %0,28 \n" /* cc into least significant bits */
"1: \n" /* we are done */
".section .fixup,\"ax\"\n" /* start of fix up section */
"2: lghi %0,2 \n" /* return unused condition code 2 */
" jg 1b \n" /* goto label 1 above */
".previous \n" /* back in text section */
".section __ex_table,\"a\"\n" /* start __extable */
" .align 8 \n"
" .quad 0b,2b \n" /* failure point 0, fixup code 2 */
".previous \n"
: "=d" (cc) : "d" (real_page_addr), "d" (xpage_index) : "cc", "1", "2"
);
#endif /* CONFIG_ARCH_S390X */
switch (cc) {
case 0: return 0;
case 1: return -EIO;
case 2: { PRINT_ERR("expanded storage lost!\n"); return -ENXIO; }
case 3: return -ENXIO;
default: return -EIO; /* should not happen */
} }
return 0;
} }
/*--------------------------------------------------------------------*/ /*
/* Measure expanded memory */ * Check if xpram is available.
/* Return value */ */
/* size of expanded memory in kB (must be a multipe of 4) */ static int __init xpram_present(void)
/*--------------------------------------------------------------------*/
int xpram_size(void)
{ {
int cc=0; unsigned long mem_page;
unsigned long base=0; int rc;
unsigned long po, pi, rpi; /* page index order, page index */
unsigned long mem_page = __get_free_page(GFP_KERNEL);
/* for po=0,1,2,... try to move in page number base+(2^po)-1 */ mem_page = (unsigned long) __get_free_page(GFP_KERNEL);
pi=1; rc = xpram_page_in(mem_page, 0);
for (po=0; po <= 32; po++) { /* pi = 2^po */ free_page(mem_page);
cc=xpram_page_in(mem_page,base+pi-1); return rc ? -ENXIO : 0;
if ( cc ) break;
pi <<= 1;
}
if ( cc && (po < 31 ) ) {
pi >>=1;
base += pi;
pi >>=1;
for ( ; pi > 0; pi >>= 1) {
rpi = pi - 1;
cc=xpram_page_in(mem_page,base+rpi);
if ( !cc ) base += pi;
}
}
free_page (mem_page);
if ( cc && (po < 31) )
return (XPRAM_KB_IN_PG * base);
else /* return maximal value possible */
return INT_MAX;
} }
/* /*
* Open and close * Return index of the last available xpram page.
*/ */
static unsigned long __init xpram_highest_page_index(void)
int xpram_open (struct inode *inode, struct file *filp)
{ {
Xpram_Dev *dev; /* device information */ unsigned long page_index, add_bit;
int num = MINOR(inode->i_rdev); unsigned long mem_page;
mem_page = (unsigned long) __get_free_page(GFP_KERNEL);
if (num >= xpram_devs) return -ENODEV; page_index = 0;
dev = xpram_devices + num; add_bit = 1ULL << (sizeof(unsigned long)*8 - 1);
while (add_bit > 0) {
if (xpram_page_in(mem_page, page_index | add_bit) == 0)
page_index |= add_bit;
add_bit >>= 1;
}
PRINT_DEBUG("calling xpram_open for device %d\n",num); free_page (mem_page);
PRINT_DEBUG(" size %dkB, name %s, usage: %d\n",
dev->size,dev->device_name, atomic_read(&(dev->usage)));
atomic_inc(&(dev->usage)); return page_index;
return 0; /* success */
} }
int xpram_release (struct inode *inode, struct file *filp) /*
* Block device make request function.
*/
static int xpram_make_request(request_queue_t *q, struct bio *bio)
{ {
Xpram_Dev *dev = xpram_devices + MINOR(inode->i_rdev); xpram_device_t *xdev;
struct bio_vec *bvec;
PRINT_DEBUG("calling xpram_release for device %d (size %dkB, usage: %d)\n",MINOR(inode->i_rdev) ,dev->size,atomic_read(&(dev->usage))); unsigned long index;
unsigned long page_addr;
unsigned long bytes;
int i;
/* if (MINOR(bio->bi_bdev->bd_dev) > xpram_devs)
* If the device is closed for the last time, start a timer /* No such device. */
* to release RAM in half a minute. The function and argument goto fail;
* for the timer have been setup in init_module() xdev = xpram_devices + MINOR(bio->bi_bdev->bd_dev);
*/ if ((bio->bi_sector & 3) != 0 || (bio->bi_size & 4095) != 0)
if (!atomic_dec_return(&(dev->usage))) { /* Request is not page-aligned. */
/* but flush it right now */ goto fail;
/* Everything is already flushed by caller -- AV */ if ((bio->bi_size >> 12) > xdev->size)
/* Request size is no page-aligned. */
goto fail;
index = (bio->bi_sector >> 3) + xdev->offset;
bio_for_each_segment(bvec, bio, i) {
page_addr = (unsigned long)
kmap(bvec->bv_page) + bvec->bv_offset;
bytes = bvec->bv_len;
if ((page_addr & 4095) != 0 || (bytes & 4095) != 0)
/* More paranoia. */
goto fail;
while (bytes > 0) {
if (bio_data_dir(bio) == READ) {
if (xpram_page_in(page_addr, index) != 0)
goto fail;
} else {
if (xpram_page_out(page_addr, index) != 0)
goto fail;
}
page_addr += 4096;
bytes -= 4096;
index++;
}
} }
return(0); set_bit(BIO_UPTODATE, &bio->bi_flags);
bio->bi_end_io(bio);
return 0;
fail:
bio_io_error(bio);
return 0;
} }
/* /*
* The ioctl() implementation * The file operations
*/ */
static int xpram_open (struct inode *inode, struct file *filp)
{
if (minor(inode->i_rdev) >= xpram_devs)
return -ENODEV;
return 0;
}
int xpram_ioctl (struct inode *inode, struct file *filp,
static int xpram_ioctl (struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
int err, size; struct hd_geometry *geo;
struct hd_geometry *geo = (struct hd_geometry *)arg; unsigned long size;
int idx;
PRINT_DEBUG("ioctl 0x%x 0x%lx\n", cmd, arg);
switch(cmd) {
case BLKGETSIZE: /* 0x1260 */ if ((!inode) || kdev_none(inode->i_rdev))
return -EINVAL;
idx = minor(inode->i_rdev);
if (idx >= xpram_devs)
return -ENODEV;
switch (cmd) {
case BLKGETSIZE:
/* Return the device size, expressed in sectors */ /* Return the device size, expressed in sectors */
return put_user( 1024* xpram_sizes[MINOR(inode->i_rdev)] return put_user(xpram_sizes[idx] << 1, (unsigned long *) arg);
/ XPRAM_SOFTSECT,
(unsigned long *) arg);
case BLKGETSIZE64: case BLKGETSIZE64:
return put_user( (u64)(1024* xpram_sizes[MINOR(inode->i_rdev)] /* Return the device size, expressed in bytes */
/ XPRAM_SOFTSECT) << 9, return put_user((u64) xpram_sizes[idx] << 10, (u64 *) arg);
(u64 *) arg); case BLKFLSBUF:
return blk_ioctl(((struct inode *) inode)->i_bdev, cmd, arg);
case BLKFLSBUF: /* flush, 0x1261 */ case BLKRRPART:
fsync_bdev(inode->i_bdev); /* re-read partition table: can't do it */
if ( capable(CAP_SYS_ADMIN) )invalidate_bdev(inode->i_bdev, 0);
return 0;
case BLKRRPART: /* re-read partition table: can't do it, 0x1259 */
return -EINVAL; return -EINVAL;
case HDIO_GETGEO: case HDIO_GETGEO:
/* /*
* get geometry: we have to fake one... trim the size to a * get geometry: we have to fake one... trim the size to a
* multiple of 64 (32k): tell we have 16 sectors, 4 heads, * multiple of 64 (32k): tell we have 16 sectors, 4 heads,
* whatever cylinders. Tell also that data starts at sector. 4. * whatever cylinders. Tell also that data starts at sector. 4.
*/ */
size = xpram_mem_avail * 1024 / XPRAM_SOFTSECT; geo = (struct hd_geometry *) arg;
/* size = xpram_mem_avail * 1024 / xpram_hardsect; */ if (geo == NULL)
size &= ~0x3f; /* multiple of 64 */ return -EINVAL;
if (geo==NULL) return -EINVAL; size = (xpram_pages * 8) & ~0x3f;
/*
* err=verify_area_20(VERIFY_WRITE, geo, sizeof(*geo));
* if (err) return err;
*/
put_user(size >> 6, &geo->cylinders); put_user(size >> 6, &geo->cylinders);
put_user( 4, &geo->heads); put_user(4, &geo->heads);
put_user( 16, &geo->sectors); put_user(16, &geo->sectors);
put_user( 4, &geo->start); put_user(4, &geo->start);
return 0; return 0;
default:
return -EINVAL;
} }
return -EINVAL; /* unknown command */
} }
/* static struct block_device_operations xpram_devops =
* The file operations
*/
struct block_device_operations xpram_devops =
{ {
owner: THIS_MODULE, owner: THIS_MODULE,
ioctl: xpram_ioctl, ioctl: xpram_ioctl,
...@@ -664,416 +382,149 @@ struct block_device_operations xpram_devops = ...@@ -664,416 +382,149 @@ struct block_device_operations xpram_devops =
}; };
/* /*
* Block-driver specific functions * Setup xpram_sizes array.
*/ */
static int __init xpram_setup_sizes(unsigned long pages)
void xpram_request(request_queue_t * queue)
{ {
Xpram_Dev *device; unsigned long mem_needed;
/* u8 *ptr; */ unsigned long mem_auto;
/* int size; */ int mem_auto_no;
int i;
unsigned long page_no; /* expanded memory page number */
unsigned long sects_to_copy; /* number of sectors to be copied */
char * buffer; /* local pointer into buffer cache */
int dev_no; /* device number of request */
int fault; /* faulty access to expanded memory */
struct request * current_req; /* working request */
while(1) {
if (blk_queue_empty(QUEUE))
return;
fault=0; /* Check number of devices. */
current_req = CURRENT; if (devs <= 0 || devs > XPRAM_MAX_DEVS) {
dev_no = DEVICE_NR(current_req->rq_dev); PRINT_ERR("invalid number %d of devices\n",devs);
/* Check if the minor number is in range */ return -EINVAL;
if ( dev_no > xpram_devs ) {
static int count = 0;
if (count++ < 5) /* print the message at most five times */
PRINT_WARN(" request for unknown device\n");
end_request(CURRENT, 0);
continue;
} }
xpram_devs = devs;
/* pointer to device structure, from the global array */ /*
device = xpram_devices + dev_no; * Copy sizes array to xpram_sizes and align partition
sects_to_copy = current_req->current_nr_sectors; * sizes to page boundary.
/* does request exceed size of device ? */ */
if ( XPRAM_SEC2KB(sects_to_copy) > xpram_sizes[dev_no] ) { mem_needed = 0;
PRINT_WARN(" request past end of device\n"); mem_auto_no = 0;
end_request(CURRENT, 0); for (i = 0; i < xpram_devs; i++) {
continue; xpram_sizes[i] = (sizes[i] + 3) & -4UL;
if (xpram_sizes[i])
mem_needed += xpram_sizes[i];
else
mem_auto_no++;
} }
/* Does request start at page boundery? -- paranoia */ PRINT_INFO(" number of devices (partitions): %d \n", xpram_devs);
#if 0 for (i = 0; i < xpram_devs; i++) {
PRINT_DEBUG(" req %lx, sect %lx, to copy %lx, buf addr %lx\n", (unsigned long) current_req, current_req->sector, sects_to_copy, (unsigned long) current_req->buffer); if (xpram_sizes[i])
#endif PRINT_INFO(" size of partition %d: %d kB\n",
buffer = current_req->buffer; i, xpram_sizes[i]);
#if XPRAM_SEC_IN_PG != 1 else
/* Does request start at an expanded storage page boundery? */ PRINT_INFO(" size of partition %d to be set "
if ( current_req->sector & (XPRAM_SEC_IN_PG - 1) ) { "automatically\n",i);
PRINT_WARN(" request does not start at an expanded storage page boundery\n");
PRINT_WARN(" referenced sector: %ld\n",current_req->sector);
end_request(CURRENT, 0);
continue;
}
/* Does request refere to partial expanded storage pages? */
if ( sects_to_copy & (XPRAM_SEC_IN_PG - 1) ) {
PRINT_WARN(" request referes to a partial expanded storage page\n");
end_request(CURRENT, 0);
continue;
}
#endif /* XPRAM_SEC_IN_PG != 1 */
/* Is request buffer aligned with kernel pages? */
if ( ((unsigned long)buffer) & (XPRAM_PGSIZE-1) ) {
PRINT_WARN(" request buffer is not aligned with kernel pages\n");
end_request(CURRENT, 0);
continue;
} }
PRINT_DEBUG(" memory needed (for sized partitions): %ld kB\n",
mem_needed);
PRINT_DEBUG(" partitions to be sized automatically: %d\n",
mem_auto_no);
/* which page of expanded storage is affected first? */ if (mem_needed > pages * 4) {
page_no = (xpram_offsets[dev_no] >> XPRAM_KB_IN_PG_ORDER) PRINT_ERR("Not enough expanded memory available\n");
+ (current_req->sector >> XPRAM_SEC_IN_PG_ORDER); return -EINVAL;
#if 0
PRINT_DEBUG("request: %d ( dev %d, copy %d sectors, at page %d ) \n", current_req->cmd,dev_no,sects_to_copy,page_no);
#endif
switch(current_req->cmd) {
case READ:
do {
if ( (fault=xpram_page_in((unsigned long)buffer,page_no)) ) {
PRINT_WARN("xpram(dev %d): page in failed for page %ld.\n",dev_no,page_no);
break;
}
sects_to_copy -= XPRAM_SEC_IN_PG;
buffer += XPRAM_PGSIZE;
page_no++;
} while ( sects_to_copy > 0 );
break;
case WRITE:
do {
if ( (fault=xpram_page_out((unsigned long)buffer,page_no))
) {
PRINT_WARN("xpram(dev %d): page out failed for page %ld.\n",dev_no,page_no);
break;
}
sects_to_copy -= XPRAM_SEC_IN_PG;
buffer += XPRAM_PGSIZE;
page_no++;
} while ( sects_to_copy > 0 );
break;
default:
/* can't happen */
end_request(CURRENT, 0);
continue;
}
if ( fault ) end_request(CURRENT, 0);
else end_request(CURRENT, 1); /* success */
} }
}
/* /*
* Kernel interfaces * partitioning:
*/ * xpram_sizes[i] != 0; partition i has size xpram_sizes[i] kB
* else: ; all partitions with zero xpram_sizes[i]
/* * partition equally the remaining space
* Parses the kernel parameters given in the kernel parameter line.
* The expected format is
* <number_of_partitions>[","<partition_size>]*
* where
* devices is a positive integer that initializes xpram_devs
* each size is a non-negative integer possibly followed by a
* magnitude (k,K,m,M,g,G), the list of sizes initialises
* xpram_sizes
*
* Arguments
* str: substring of kernel parameter line that contains xprams
* kernel parameters.
* ints: not used -- not in Version > 2.3 any more
*
* Result 0 on success, -EINVAl else -- only for Version > 2.3
*
* Side effects
* the global variabls devs is set to the value of
* <number_of_partitions> and sizes[i] is set to the i-th
* partition size (if provided). A parsing error of a value
* results in this value being set to -EINVAL.
*/ */
int xpram_setup (char *str) if (mem_auto_no) {
{ mem_auto = ((pages - mem_needed / 4) / mem_auto_no) * 4;
devs = xpram_read_int(&str); PRINT_INFO(" automatically determined "
if ( devs != -EINVAL ) "partition size: %ld kB\n", mem_auto);
if ( xpram_read_size_list_tail(&str,devs,sizes) < 0 ) { for (i = 0; i < xpram_devs; i++)
PRINT_ERR("error while reading xpram parameters.\n"); if (xpram_sizes[i] == 0)
return -EINVAL; xpram_sizes[i] = mem_auto;
} }
else
return 0; return 0;
else
return -EINVAL;
} }
/* static int __init xpram_setup_blkdev(void)
* initialize xpram device driver
*
* Result: 0 ok
* negative number: negative error code
*/
int xpram_init(void)
{ {
int result, i; request_queue_t *q;
int mem_usable; /* net size of expanded memory */ unsigned long offset;
int mem_needed=0; /* size of expanded memory needed to fullfill int i, rc;
* requirements of non-zero parameters in sizes
*/
int mem_auto_no=0; /* number of (implicit) zero parameters in sizes */
int mem_auto; /* automatically determined device size */
int minor_length; /* store the length of a minor (w/o '\0') */
int minor_thresh; /* threshhold for minor lenght */
request_queue_t *q; /* request queue */
/* /*
* Copy the (static) cfg variables to public prefixed ones to allow * Register xpram major.
* snoozing with a debugger.
*/ */
rc = devfs_register_blkdev(XPRAM_MAJOR, XPRAM_NAME, &xpram_devops);
xpram_blksize = blksize; if (rc < 0) {
xpram_hardsect = hardsect; PRINT_ERR("Can't get xpram major %d\n", XPRAM_MAJOR);
return rc;
PRINT_INFO("initializing: %s\n","");
/* check arguments */
xpram_major = major;
if ( (devs <= 0) || (devs > XPRAM_MAX_DEVS) ) {
PRINT_ERR("invalid number %d of devices\n",devs);
PRINT_ERR("Giving up xpram\n");
return -EINVAL;
}
xpram_devs = devs;
for (i=0; i < xpram_devs; i++) {
if ( sizes[i] < 0 ) {
PRINT_ERR("Invalid partition size %d kB\n",xpram_sizes[i]);
PRINT_ERR("Giving up xpram\n");
return -EINVAL;
} else {
xpram_sizes[i] = NEXT4(sizes[i]); /* page align */
if ( sizes[i] ) mem_needed += xpram_sizes[i];
else mem_auto_no++;
}
}
PRINT_DEBUG(" major %d \n", xpram_major);
PRINT_INFO(" number of devices (partitions): %d \n", xpram_devs);
for (i=0; i < xpram_devs; i++) {
if ( sizes[i] )
PRINT_INFO(" size of partition %d: %d kB\n", i, xpram_sizes[i]);
else
PRINT_INFO(" size of partition %d to be set automatically\n",i);
} }
PRINT_DEBUG(" memory needed (for sized partitions): %d kB\n", mem_needed);
PRINT_DEBUG(" partitions to be sized automatically: %d\n", mem_auto_no);
#if 0
/* Hardsect can't be changed :( */
/* I try it any way. Yet I must distinguish
* between hardsects (to be changed to 4096)
* and soft sectors, hard-coded for buffer
* sizes within the requests
*/
if (hardsect != 512) {
PRINT_ERR("Can't change hardsect size\n");
hardsect = xpram_hardsect = 512;
}
#endif
PRINT_INFO(" hardsector size: %dB \n",xpram_hardsect);
/*
* Register your major, and accept a dynamic number
*/
result = devfs_register_blkdev(xpram_major, "xpram", &xpram_devops);
if (result < 0) {
PRINT_ERR("Can't get major %d\n",xpram_major);
PRINT_ERR("Giving up xpram\n");
return result;
}
xpram_devfs_handle = devfs_mk_dir (NULL, "slram", NULL); xpram_devfs_handle = devfs_mk_dir (NULL, "slram", NULL);
devfs_register_series (xpram_devfs_handle, "%u", XPRAM_MAX_DEVS, devfs_register_series (xpram_devfs_handle, "%u", xpram_devs,
DEVFS_FL_DEFAULT, XPRAM_MAJOR, 0, DEVFS_FL_DEFAULT, XPRAM_MAJOR, 0,
S_IFBLK | S_IRUSR | S_IWUSR, S_IFBLK | S_IRUSR | S_IWUSR,
&xpram_devops, NULL); &xpram_devops, NULL);
if (xpram_major == 0) xpram_major = result; /* dynamic */
major = xpram_major; /* Use `major' later on to save typing */
result = -ENOMEM; /* for the possible errors */
/*
* measure expanded memory
*/
xpram_mem_avail = xpram_size();
if (!xpram_mem_avail) {
PRINT_ERR("No or not enough expanded memory available\n");
PRINT_ERR("Giving up xpram\n");
result = -ENODEV;
goto fail_malloc;
}
PRINT_INFO(" %d kB expanded memory found.\n",xpram_mem_avail );
/*
* Assign the other needed values: request, size, blksize,
* hardsect. All the minor devices feature the same value.
* Note that `xpram' defines all of them to allow testing non-default
* values. A real device could well avoid setting values in global
* arrays if it uses the default values.
*/
q = BLK_DEFAULT_QUEUE(major);
blk_init_queue (q, xpram_request);
blk_queue_hardsect_size(q, xpram_hardsect);
/* we want to have XPRAM_UNUSED blocks security buffer between devices */
mem_usable=xpram_mem_avail-(XPRAM_UNUSED*(xpram_devs-1));
if ( mem_needed > mem_usable ) {
PRINT_ERR("Not enough expanded memory available\n");
PRINT_ERR("Giving up xpram\n");
goto fail_malloc;
}
/* /*
* partitioning: * Assign the other needed values: make request function, sizes and
* xpram_sizes[i] != 0; partition i has size xpram_sizes[i] kB * hardsect size. All the minor devices feature the same value.
* else: ; all partitions i with xpram_sizesxpram_size[i]
* partition equally the remaining space
*/ */
q = BLK_DEFAULT_QUEUE(XPRAM_MAJOR);
if ( mem_auto_no ) { blk_queue_make_request(q,xpram_make_request);
mem_auto=LAST4((mem_usable-mem_needed)/mem_auto_no); blk_queue_hardsect_size(q, 4096);
PRINT_INFO(" automatically determined partition size: %d kB\n", mem_auto); blk_size[XPRAM_MAJOR] = xpram_sizes;
for (i=0; i < xpram_devs; i++)
if (xpram_sizes[i] == 0) xpram_sizes[i] = mem_auto;
}
blk_size[major] = xpram_sizes;
xpram_offsets = kmalloc(xpram_devs * sizeof(int), GFP_KERNEL);
if (!xpram_offsets) {
PRINT_ERR("Not enough memory for xpram_offsets\n");
PRINT_ERR("Giving up xpram\n");
goto fail_malloc;
}
xpram_offsets[0] = 0;
for (i=1; i < xpram_devs; i++)
xpram_offsets[i] = xpram_offsets[i-1] + xpram_sizes[i-1] + XPRAM_UNUSED;
#if 0
for (i=0; i < xpram_devs; i++)
PRINT_DEBUG(" device(%d) offset = %d kB, size = %d kB\n",i, xpram_offsets[i], xpram_sizes[i]);
#endif
/* /*
* allocate the devices -- we can't have them static, as the number * Setup device structures.
* can be specified at load time
*/ */
offset = 0;
xpram_devices = kmalloc(xpram_devs * sizeof (Xpram_Dev), GFP_KERNEL); for (i = 0; i < xpram_devs; i++) {
if (!xpram_devices) { xpram_devices[i].size = xpram_sizes[i] / 4;
PRINT_ERR("Not enough memory for xpram_devices\n"); xpram_devices[i].offset = offset;
PRINT_ERR("Giving up xpram\n"); offset += xpram_devices[i].size;
goto fail_malloc_devices;
}
memset(xpram_devices, 0, xpram_devs * sizeof (Xpram_Dev));
minor_length = 1;
minor_thresh = 10;
for (i=0; i < xpram_devs; i++) {
/* data and usage remain zeroed */
xpram_devices[i].size = xpram_sizes[i]; /* size in kB not in bytes */
atomic_set(&(xpram_devices[i].usage),0);
if (i == minor_thresh) {
minor_length++;
minor_thresh *= 10;
} }
xpram_devices[i].device_name =
kmalloc(1 + strlen(XPRAM_DEVICE_NAME_PREFIX) + minor_length,GFP_KERNEL);
if ( xpram_devices[i].device_name == NULL ) {
PRINT_ERR("Not enough memory for xpram_devices[%d].device_name\n",i);
PRINT_ERR("Giving up xpram\n");
goto fail_devfs_register;
}
sprintf(xpram_devices[i].device_name,XPRAM_DEVICE_NAME_PREFIX "%d",i);
PRINT_DEBUG("initializing xpram_open for device %d\n",i);
PRINT_DEBUG(" size %dkB, name %s, usage: %d\n",
xpram_devices[i].size,xpram_devices[i].device_name, atomic_read(&(xpram_devices[i].usage)));
#if 0 /* WHY? */ return 0;
xpram_devices[i].devfs_entry =
devfs_register(NULL /* devfs root dir */,
xpram_devices[i].device_name, 0,
0 /* flags */,
XPRAM_MAJOR,i,
0755 /* access mode */,
0 /* uid */, 0 /* gid */,
&xpram_devops,
(void *) &(xpram_devices[i])
);
if ( xpram_devices[i].devfs_entry == NULL ) {
PRINT_ERR("devfs system registry failed\n");
PRINT_ERR("Giving up xpram\n");
goto fail_devfs_register;
}
#endif /* WHY? */
}
return 0; /* succeed */
/* clean up memory in case of failures */
fail_devfs_register:
for (i=0; i < xpram_devs; i++) {
if ( xpram_devices[i].device_name )
kfree(xpram_devices[i].device_name);
}
kfree(xpram_devices);
kfree (xpram_offsets);
fail_malloc_devices:
fail_malloc:
/* ??? unregister_chrdev(major, "xpram"); */
unregister_blkdev(major, "xpram");
return result;
} }
/* /*
* Finally, the module stuff * Finally, the init/exit functions.
*/ */
static void __exit xpram_exit(void)
int init_module(void)
{ {
int rc = 0; blk_clear(XPRAM_MAJOR);
devfs_unregister_blkdev(XPRAM_MAJOR, XPRAM_NAME);
PRINT_INFO ("trying to load module\n"); devfs_unregister(xpram_devfs_handle);
rc = xpram_init (); unregister_sys_device(&xpram_sys_device);
if (rc == 0) {
PRINT_INFO ("Module loaded successfully\n");
} else {
PRINT_WARN ("Module load returned rc=%d\n", rc);
}
return rc;
} }
void cleanup_module(void) static int __init xpram_init(void)
{ {
int i; int rc;
/* first of all, reset all the data structures */ /* Find out size of expanded memory. */
kfree(xpram_offsets); if (xpram_present() != 0) {
blk_clear(major); PRINT_WARN("No expanded memory available\n");
return -ENODEV;
/* finally, the usual cleanup */ }
devfs_unregister(xpram_devfs_handle); xpram_pages = xpram_highest_page_index();
if (devfs_unregister_blkdev(MAJOR_NR, "xpram")) PRINT_INFO(" %li pages expanded memory found (%li KB).\n",
printk(KERN_WARNING "xpram: cannot unregister blkdev\n"); xpram_pages, xpram_pages*4);
kfree(xpram_devices); rc = xpram_setup_sizes(xpram_pages);
if (rc)
return rc;
rc = register_sys_device(&xpram_sys_device);
if (rc)
return rc;
rc = xpram_setup_blkdev();
if (rc)
unregister_sys_device(&xpram_sys_device);
return rc;
} }
module_init(xpram_init);
module_exit(xpram_exit);
drivers/s390/block/xpram.h deleted 100644 → 0
View file @ 144d6034
/*
* xpram.h -- definitions for the char module
*
*********/
#include <linux/ioctl.h>
#include <asm/atomic.h>
#include <linux/major.h>
/* version dependencies have been confined to a separate file */
/*
* Macros to help debugging
*/
#define XPRAM_NAME "xpram" /* name of device/module */
#define XPRAM_DEVICE_NAME_PREFIX "slram" /* Prefix device name for major 35 */
#define XPRAM_DEVS 1 /* one partition */
#define XPRAM_RAHEAD 8 /* no real read ahead */
#define XPRAM_PGSIZE 4096 /* page size of (expanded) mememory pages
* according to S/390 architecture
*/
#define XPRAM_BLKSIZE XPRAM_PGSIZE /* must be equalt to page size ! */
#define XPRAM_HARDSECT XPRAM_PGSIZE /* FIXME -- we have to deal with both
* this hard sect size and in some cases
* hard coded 512 bytes which I call
* soft sects:
*/
#define XPRAM_SOFTSECT 512
#define XPRAM_MAX_DEVS 32 /* maximal number of devices (partitions) */
#define XPRAM_MAX_DEVS1 33 /* maximal number of devices (partitions) +1 */
/* The following macros depend on the sizes above */
#define XPRAM_KB_IN_PG 4 /* 4 kBs per page */
#define XPRAM_KB_IN_PG_ORDER 2 /* 2^? kBs per page */
/* Eventhough XPRAM_HARDSECT is set to 4k some data structures use hard
* coded 512 byte sa sector size
*/
#define XPRAM_SEC2KB(x) ((x >> 1) + (x & 1)) /* modifier used to compute size
in kB from number of sectors */
#define XPRAM_SEC_IN_PG 8 /* 8 sectors per page */
#define XPRAM_SEC_IN_PG_ORDER 3 /* 2^? sectors per page */
#define XPRAM_UNUSED 40 /* unused space between devices,
* in kB, i.e.
* must be a multiple of 4
*/
/*
* The xpram device is removable: if it is left closed for more than
* half a minute, it is removed. Thus use a usage count and a
* kernel timer
*/
typedef struct Xpram_Dev {
int size; /* size in KB not in Byte - RB - */
atomic_t usage;
char * device_name; /* device name prefix in devfs */
devfs_handle_t devfs_entry; /* handle needed to unregister dev from devfs */
u8 *data;
} Xpram_Dev;
/* 2.2: void xpram_setup (char *, int *); */
/* begin 2.3 */
int xpram_setup (char *);
/* end 2.3 */
int xpram_init(void);
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7