gmane.comp.file-systems.arla.general

FW: Looking for AFS Information

Morales, Ana — 2011-08-22T23:21:23

All,

Thank you all for your kind /prompt responses.  I am all set, no need for any more info.

Best Regards,

Ana

From: Morales, Ana
Sent: Monday, August 22, 2011 11:43 AM
To: 'arla-drinkers< at >stacken.kth.se'
Subject: Looking for AFS Information


Hello,



I see that Arla is a project that studies Andrew File system and it appears that you have implemented in your university?   Is this a project that still active at your university?    I am trying to find out if there are any vendors (or open source) that have taken  AFS and make it a product.    My understanding is that a while back IBM had purchased Transarc  but there is no support for that anymore.



I am looking for file systems products that can provide access to global data (flat files) efficiently in an optimized way, in real time; the clients can be sitting in multiple geographic locations.    I thought to write to you since seem very familiar with AFS and  perhaps can you provide me with names or refer me to someone   else that can help me pursue this.



Thanks for your help in advance!



Ana Morales
IT Market Research Analyst | IT Strategy, Architecture & Innovation
Intel Corp., Hudson, MA | office  978-553-5617






_______________________________________________
Arla-drinkers mailing list
Arla-drinkers< at >stacken.kth.se
https://lists.stacken.kth.se/mailman/listinfo/arla-drinkers

Re: Looking for AFS Information

Jeffrey Altman — 2011-08-22T22:20:32

Your File System, Inc. provides commercial support for advanced AFS
deployments based upon OpenAFS.  Under funding by the U.S. Department of
Energy YFS has developed an advanced implementation for clients and
servers providing enhanced performance, functionality and performance.
Later this year YFS will be announcing a line of storage appliances.

Please feel free to contact me directly for more information.

Jeffrey Altman
President
Your File System, Inc.


On 8/22/2011 11:43 AM, Morales, Ana wrote:

_______________________________________________
Arla-drinkers mailing list
Arla-drinkers< at >stacken.kth.se
https://lists.stacken.kth.se/mailman/listinfo/arla-drinkers

Re: Looking for AFS Information

Jason Edgecombe — 2011-08-22T22:26:49

For OpenAFS support, go here:
http://openafs.org/support.html

Jason

Re: Looking for AFS Information

Tomas Olsson — 2011-08-22T21:05:44

I'm afraid Arla isn't actively maintained nowadays.

Take a look at http://openafs.org/
OpenAFS is based on the IBM/Transarc code and it is well maintained. They provide a list of companies that provide commercial support.

There is also an AFS client included in the standard Linux kernel if that's of any interest.

AFS is good at handling distributed reading of files that are not modified too much concurrently. It's probably not the fastest file system out there, but it's mature and OpenAFS supports a wide range of operating systems.

HTH
   /t

Looking for AFS Information

Morales, Ana — 2011-08-22T15:43:23

Hello,



I see that Arla is a project that studies Andrew File system and it appears that you have implemented in your university?   Is this a project that still active at your university?    I am trying to find out if there are any vendors (or open source) that have taken  AFS and make it a product.    My understanding is that a while back IBM had purchased Transarc  but there is no support for that anymore.



I am looking for file systems products that can provide access to global data (flat files) efficiently in an optimized way, in real time; the clients can be sitting in multiple geographic locations.    I thought to write to you since seem very familiar with AFS and  perhaps can you provide me with names or refer me to someone   else that can help me pursue this.



Thanks for your help in advance!



Ana Morales
IT Market Research Analyst | IT Strategy, Architecture & Innovation
Intel Corp., Hudson, MA | office  978-553-5617






_______________________________________________
Arla-drinkers mailing list
Arla-drinkers< at >stacken.kth.se
https://lists.stacken.kth.se/mailman/listinfo/arla-drinkers

Re: AFS and 'afs' URI scheme

Jeffrey Hutzelman — 2011-03-31T22:56:29


I suppose this is _a_ right place to ask, but a better place would be
afs3-standardization< at >openafs.org, which is the official home of
standardization work related to the AFS 3 protocol suite.


I don't recall seeing any such discussion; where did this happen?

AFS and 'afs' URI scheme

Mykyta Yevstifeyev — 2011-03-31T14:51:20

Hello all,

I am writing to request some information regarding AFS and its current 
implementations.  I hope this is the right list to ask.

So my question is whether the latest versions of current AFS 
implementation still use 'afs' URI scheme.  The 'afs' URI scheme can be 
found mentioned as reserved for further standardization in RFC 1738 
(http://tools.ietf.org/html/rfc1738) dated December 1994, but there is 
no any definition of the scheme's syntax/semantics.

Currently the 'afs' URI scheme is registered by IANA as Provisional with 
reference to RFC 1738.  In the previous year there were some some 
discussions in the IETF regarding what should be done with it.  However 
there was no consensus on any actions; two were proposed - move the 
scheme to Historical category or remain it as is.  I'd like to hear the 
opinion of AFS experts.

Thank you in advance,
Mykyta Yevstifeyev
_______________________________________________
Arla-drinkers mailing list
Arla-drinkers< at >stacken.kth.se
https://lists.stacken.kth.se/mailman/listinfo/arla-drinkers

AFS & Kerberos Best Practices Workshop 2011: Registration availableand other details

Derrick Brashear — 2011-03-23T15:10:23

Due to unforeseen circumstances, the opening of registration had been
delayed, but is now open!
Early registration ends April 20. Normal registration ends May 24.
Late registration (after May 24) will be available on-site.

Additionally, on Friday afternoon, there is an opportunity to visit
Lowe's Motor Speedway to experience NASCAR driving.  If we have
10 or more that commit to the racing experience, we will get a 10%
discount.  Options are either do the ride along which will cost
$116.99
for several laps around the track or you can do the driving experience
which will be a 3 hour training class which starts at 2:00 and then
you get to drive around the track for 5 minutes for $331.99.  The ride
along starts at 3:00 on Friday.  Here is the website if you want to
check it out:
www.nascarracingexperience.com.

As before, this year's Workshop will be held at the University of
North Carolina at
Charlotte, June 6-10, 2011.

We look forward to seeing you in Charlotte!
http://workshop.openafs.org/afsbpw11/

Derrick
for the Organizers of the AFS & Kerberos Workshop

AFS & Kerberos Best Practices Workshop 2011: CFP extended tilSaturday; Registration available tomorrow

Derrick Brashear — 2011-03-03T15:19:43

The organizers of the AFS & Kerberos Best Practices Workshop 2011
previously announced the Call For Participation.  The CFP now closes
on March 5, 2011.
Acceptances will be made on a continuing schedule based on fit with other talks.

This year's Workshop will be held at the University of North Carolina at
Charlotte, June 6-10, 2011.

We look forward to hearing about your talk!
http://workshop.openafs.org/afsbpw11/cfp.html

Additionally, registration will be available tomorrow.

Derrick
for the Organizers of the AFS & Kerberos Workshop

CFP: AFS & Kerberos Best Practices Workshop 2011

Derrick Brashear — 2011-02-04T00:22:02

The organizers of the AFS & Kerberos Best Practices Workshop 2011
announces the Call For Participation.  The CFP closes on March 1, 2011.
Acceptances will be made on a continuing schedule based on fit with
other talks.

This year's Workshop will be held at the University of North Carolina at
Charlotte, June 6-10, 2011.


The AFS & Kerberos Best Practices Workshop is a week long conference
for those who work with OpenAFS and Kerberos, from the novice to the
experienced.  The week is filled with two full-day classes introducing
AFS and Kerberos and two and one half days of talks by your peers and
colleagues.

 - Work completed                   - Work in progress
 - Theories                               - Best practices
 - Related research                  - Updates on previous talks
 - Advanced tutorials                - Panel sessions

or something else that has come to you while working with AFS and/or
Kerberos.

Talks are encouraged from basic to complex.  Topics may include, but
are not limited to:

AFS best practices                      AFS performance tuning
Benchmarking                             AFS server scaling
Service monitoring                      AFS & Kerberos 5
AFS related tools                        Kerberos related tools
Upgrade strategies                     Unique uses of AFS and/or Kerberos
Backups                                      Web integration
Administration delegation            AFS on non-Unix platforms
Automation                              Work on new features


Past talks have included:

Using Kebreros for Web Authentication   Accessing OpenAFS Through The Web
Backup Strategies                                    A View of Rx
Kerberos & Grid Systems                         Automated Keytab Installations
Hacking AFS Dump Volumes                   Your First Submission to OpenAFS
Tuning the OpenAFS Unix Client Cache Manager
Customizing installers for OpenAFS and Kerberos for Windows
NetBSD, Kerberos & AFS: From Zero to Distributed Filesystem in N Easy Steps

We look forward to hearing about your talk!
http://workshop.openafs.org/afsbpw11/cfp.html

Derrick
for the Organizers of the AFS & Kerberos Workshop

Re: [OpenAFS] Consensus Call - AFS3-Standardization Charter --nomination/Kim

Kim Kimball — 2010-08-24T20:24:11

Hi Jeffrey,

Jeff Altman asked me to respond to your email about nomination for the 
standardization work.

Can't find that email, but I do accept the nomination, which I believe 
is what Jeff A was after.

Thanks.

Kim


On 7/7/10 5:08 PM, Jeffrey Hutzelman wrote:

Re: Arla on Mac OS 10.6

Tomas Olsson — 2010-07-28T20:15:36

Any chance you could provide a core dump or panic log?

See
http://developer.apple.com/mac/library/technotes/tn2002/tn2063.html
http://developer.apple.com/mac/library/technotes/tn2004/tn2118.html

I'll try to catch up with the patches.

thanks
   /t

Re: Arla on Mac OS 10.5

Tomas Olsson — 2010-07-28T19:55:59

Great!

I found some old instructions on building arla on MacOS, for use in a dmg.
See below. Perhaps it can be helpful if you want to use more recent
heimdal. And I trust you've already found make-mac-package.sh.in in the
cvs tree.

/t

Building heimdal and arla for Mac OS X:
get the latest libtool and automake/-conf
 (for example, http://www.pdc.kth.se/~tol/habahat.sh, run habahat.sh,
  export PATH)
get ftp://ftp.pdc.kth.se/pub/heimdal/src/snapshots/heimdal-20060317
unpack heimdal
cd heimdal-2006...
do `autoreconf -f -i` to be able to handle CFLAGS properly, with the new
 libtool etc.

cd <your build dir>

on ppc, run heimdal-2006.../configure CFLAGS='-O2 -g -isysroot/Developer/SDKs/MacOSX10.4u.sdk -arch i386 -arch ppc' && make
or,
on intel, run heimdal-2006.../configure CFLAGS='-O2 -g -arch i386 -arch ppc' && make

make install


Arla:
(sh HACKING if needed (to regenerate configure in cvs tree))
configure --with-krb5=<your heimdal> --without-x CFLAGS=<as above> && make

Re: [AFS3-std] Consensus Call - AFS3-Standardization Charter

Michael Meffie — 2010-07-16T13:05:08


I support this.

Regards,
Mike

Re: Arla on Mac OS 10.6

Bo Brantén — 2010-07-15T18:25:50

Hello,

I have now tested Arla on Mac OS 10.6 also and the result was the same as 
for 10.5, that is if you install the binary package for 10.4 and update 
the kernel module it will work fine except for the shutdown bug. I used 
the same driver that I compiled for 10.5 for instructions see my previous 
mail. Only one small change was needed in the startup script for arla, 
chancge kextload to kextutil or remove option "-s".

So the only thing that is left to solve is the shutdown bug.

Bo Branten

Re: Arla on Mac OS 10.5

Bo Brantén — 2010-07-12T15:55:34

A few aditional things:

After ./configure but before make edit arla-0.90/include/config.h so it 
says: #define HAVE_OPENSSL 1

If using ./configure --with-krb5=/usr/arla instead of heimdal all the apps 
and libs compile clean and one don't need to install heimdal, this works 
fine on 10.4 and 10.5.

When shuttding down the computer crashes as others has reported already on 
this mailing list, I don't think I have the knowledge to debug that 
problem so I leave it to others and continue to test on Mac OS 10.6 
instead.

Arla on Mac OS 10.5

Bo Brantén — 2010-07-12T13:33:42

As has been reported here before the binary distribution of Arla 0.90 for 
Mac OS available on stacken works on 10.4 but on 10.5 one get an error on 
multiple symbols for some string functions when trying to load the kernel 
module so I tryed to compile arla myself on 10.5 and here is how it whent:

Install the binary disribution for 10.4 (only the kernel module needs to 
be updated for 10.5)
Install heimdal
Install openssl
in arla-0.90 run: ./configure --with-krb5=/usr/heimdal
patch nnpfs/bsd/nnpfs_common.c:
patch nnpfs/bsd/nnpfs_syscalls-common.c:
< #ifdef HAVE_KERNEL_KAUTH_CRED_GETUID
---
< #else
---
< #endif
---
compile arla, nnpfs will be built, compiling apps and libs will fail but 
we only need the kernel module...
sudo cp /Users/bobranten/src/arla-0.90/nnpfs/bsd/nnpfs_mod.o 
/usr/arla/bin/nnpfs.kext/Contents/MacOS/nnpfs
sudo chmod +x /usr/arla/bin/nnpfs.kext/Contents/MacOS/nnpfs
sudo /usr/arla/sbin/startarla
ls /afs/stacken.kth.se/ftp/pub
cat /afs/stacken.kth.se/ftp/pub/README
It works!

Bo Branten

How to compile Arla on Mac OS

Bo Brantén — 2010-07-11T22:26:40

Hello,

I intended to try Arla on different versions of Mac OS and started with 
10.4, the binary package on stacken works fine as expected but before 
moving on to 10.5 I wanted to compile it myself on 10.4 first and I got 
the compile error shown below, I tryed both just ./configure and 
./configure --with-krb5=/usr/heimdal and got the same error so I wanted to 
ask if anyone has an advice on this?

Bo Branten

...
Making all in rxkad
/bin/sh ../libtool --tag=CC --mode=compile gcc -DHAVE_CONFIG_H -I. -I. 
-I../include -I../include -I../lib/roken -I../lib/roken -I../include -I. 
-I. -I../include -I./../include -I.. -I./.. -I../include 
-I/usr/heimdal/include     -Wall -Wmissing-prototypes -Wpointer-arith 
-Wbad-function-cast -Wmissing-declarations -Wnested-externs -DINET6 -g 
-Wall -Wmissing-prototypes -Wpointer-arith -Wmissing-declarations 
-Wnested-externs -c -o rxk_serv.lo rxk_serv.c
  gcc -DHAVE_CONFIG_H -I. -I. -I../include -I../include -I../lib/roken 
-I../lib/roken -I../include -I. -I. -I../include -I./../include -I.. 
-I./.. -I../include -I/usr/heimdal/include -Wall -Wmissing-prototypes 
-Wpointer-arith -Wbad-function-cast -Wmissing-declarations 
-Wnested-externs -DINET6 -g -Wall -Wmissing-prototypes -Wpointer-arith 
-Wmissing-declarations -Wnested-externs -c rxk_serv.c -o rxk_serv.o
In file included from ./krb4.h:82,
                  from rxk_serv.c:47:
./krb4-protos.h:95: error: parse error before 'DES_cblock'
rxk_serv.c: In function 'decode_krb4_ticket':
rxk_serv.c:376: error: 'DES_cblock' undeclared (first use in this 
function)
rxk_serv.c:376: error: (Each undeclared identifier is reported only once
rxk_serv.c:376: error: for each function it appears in.)
rxk_serv.c:376: error: parse error before 'key'
rxk_serv.c:377: error: 'DES_key_schedule' undeclared (first use in this 
function)
rxk_serv.c:384: error: 'key' undeclared (first use in this function)
rxk_serv.c:385: warning: implicit declaration of function 'DES_key_sched'
rxk_serv.c:385: warning: nested extern declaration of 'DES_key_sched'
rxk_serv.c:385: error: 'serv_sched' undeclared (first use in this 
function)
rxk_serv.c:392: error: parse error before ')' token
make[1]: *** [rxk_serv.lo] Error 1
make: *** [all-recursive] Error 1
bo-brantens-dator:~/src/arla-0.90 bobranten$

Re: PATCH: Arla CVS Current on Linux 2.6.24-2.6.35-rc1

Bo Brantén — 2010-07-11T16:59:31

fix for leak in a reference count

(this patch is rather small now since tol has checked in all the other 
stuff in CVS)

Bo Branten
diff -uprN arla-new-cvs.bak/nnpfs/linux/nnpfs_syscalls.c arla-new-cvs/nnpfs/linux/nnpfs_syscalls.c
--- arla-new-cvs.bak/nnpfs/linux/nnpfs_syscalls.c2010-06-29 23:14:15.000000000 +0200
+++ arla-new-cvs/nnpfs/linux/nnpfs_syscalls.c2010-07-11 18:45:36.002095539 +0200
< at >< at > -257,7 +257,9 < at >< at > nnpfs_get_pag_group(void)
 #endif
     int i;
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     get_group_info(gi);
+#endif
 
     i = find_pag(gi);
     if (i != NNPFS_PAG_NOTFOUND)
< at >< at > -287,7 +289,9 < at >< at > store_pag(nnpfs_pag_t pagnum)
     int found = 0;
     int i, k;
     
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)    
     get_group_info(old_gi);
+#endif
 
     i = find_pag(old_gi);
     if (i != NNPFS_PAG_NOTFOUND)
_______________________________________________
Arla-drinkers mailing list
Arla-drinkers< at >stacken.kth.se
https://lists.stacken.kth.se/mailman/listinfo/arla-drinkers

Re: PATCH: Arla 0.90 on Linux 2.6.24-2.6.35-rc1

Bo Brantén — 2010-07-11T16:58:19

fix for leak in a reference count

Bo Branten
diff -uprN arla-0.90/nnpfs/linux/nnpfs_blocks.c arla-0.90-new/nnpfs/linux/nnpfs_blocks.c
--- arla-0.90/nnpfs/linux/nnpfs_blocks.c2007-01-08 14:24:24.000000000 +0100
+++ arla-0.90-new/nnpfs/linux/nnpfs_blocks.c2010-07-11 17:18:26.572458961 +0200
< at >< at > -34,7 +34,7 < at >< at >
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* $Id: nnpfs_blocks.c,v 1.3 2007/01/08 13:24:24 tol Exp $ */
+/* $Id: nnpfs_blocks.c,v 1.4 2008/03/08 21:38:16 tol Exp $ */
 
 #include <nnpfs/nnpfs_locl.h>
 #include <nnpfs/nnpfs_fs.h>
< at >< at > -302,6 +302,24 < at >< at > nnpfs_block_extend(struct nnpfs_node *no
     return ret;
 }
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
+/*
+ * Helper to emulate vfs_path_lookup() on linux < 2.6.23
+ */
+static int
+vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
+const char *cachename, unsigned int flags,
+struct nameidata *nd)
+{
+    nd->dentry = dget(dentry);
+    nd->mnt = mntget(mnt);
+    nd->last_type = LAST_ROOT;
+    nd->depth = 0;
+    nd->flags = flags;
+    return path_walk(cachename, nd);
+}
+#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23) */
+
 /*
  * open indicated cache block file. needs to be closed by caller.
  *
< at >< at > -322,6 +340,10 < at >< at > nnpfs_block_open(struct nnpfs_node *node
     uid_t saveuid;
     gid_t savegid;
     int ret;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
+    const struct cred *old_cred;
+    struct cred *override_cred;
+#endif
 
     BUG_ON(!nnpfsp);
     BUG_ON(flags & O_CREAT && file != NULL);
< at >< at > -346,21 +368,26 < at >< at > nnpfs_block_open(struct nnpfs_node *node
     BUG_ON(!nnpfsp->cachedir || !nnpfsp->cacheroot);
     
     /* use the nfsd trick to give us access */
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     saveuid = current->fsuid;
     savegid = current->fsgid;
     current->fsuid = nnpfsp->uid;
     current->fsgid = nnpfsp->gid;
-
-    nd.dentry = dget(nnpfsp->cachedir);
-    nd.mnt = mntget(nnpfsp->cacheroot);
-    nd.last_type = LAST_NORM;
-    nd.depth = 0;
-    nd.flags = 0;
-    
-    if (flags & O_CREAT)
-nd.flags = LOOKUP_PARENT;
-    
-    ret = path_walk(cachename, &nd);
+#else
+    saveuid = current_fsuid();
+    savegid = current_fsgid();
+    override_cred = prepare_creds();
+    if (!override_cred)
+        return -ENOMEM;
+    override_cred->fsuid = nnpfsp->uid;
+    override_cred->fsgid = nnpfsp->gid;
+    old_cred = override_creds(override_cred);
+#endif
+
+    ret = vfs_path_lookup(nnpfsp->cachedir, nnpfsp->cacheroot,
+  cachename,
+  flags & O_CREAT ? LOOKUP_PARENT : 0,
+  &nd);
     if (ret) {
 uint32_t nmasks = node->data.nmasks;
 uint32_t mask;
< at >< at > -391,12 +418,21 < at >< at > nnpfs_block_open(struct nnpfs_node *node
 if (IS_ERR(dentry)) {
     ret = PTR_ERR(dentry);
 } else {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
     ret = vfs_create(nd.dentry->d_inode, dentry, S_IRUSR|S_IWUSR, &nd);
+#else
+    ret = vfs_create(nd.path.dentry->d_inode, dentry, S_IRUSR|S_IWUSR, &nd);
+#endif
     dput(dentry);
 }
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 mutex_unlock(&nd.dentry->d_inode->i_mutex);
 path_release(&nd);
+#else
+mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
+path_put(&nd.path);
+#endif
 
 if (ret) {
     printk("nnpfs_block_open(%s) create failed: %d\n", cachename, -ret);
< at >< at > -410,12 +446,22 < at >< at > nnpfs_block_open(struct nnpfs_node *node
     ret = nnpfs_block_extend(node, offset);
 }
     } else {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 struct file *f = dentry_open(nd.dentry, nd.mnt, flags);
+#elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)
+struct file *f = dentry_open(nd.path.dentry, nd.path.mnt, flags);
+#else
+        struct file *f = dentry_open(nd.path.dentry, nd.path.mnt, flags, current_cred());
+#endif
 if (IS_ERR(f)) {
     ret = PTR_ERR(f);
     printk("nnpfs_block_open(%s) open failed: %d\n", cachename, -ret);
     nnpfs_debug_oops();
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
     path_release(&nd);
+#else
+    path_put(&nd.path);
+#endif
 } else {
     *file = f;
 }
< at >< at > -424,8 +470,13 < at >< at > nnpfs_block_open(struct nnpfs_node *node
     /* path_release() is usually handled on close */
 
  out:
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     current->fsuid = saveuid;
     current->fsgid = savegid;
+#else
+    revert_creds(old_cred);
+    put_cred(override_cred);
+#endif
 
     return ret;
 }
diff -uprN arla-0.90/nnpfs/linux/nnpfs_inodeops.c arla-0.90-new/nnpfs/linux/nnpfs_inodeops.c
--- arla-0.90/nnpfs/linux/nnpfs_inodeops.c2006-12-11 17:35:26.000000000 +0100
+++ arla-0.90-new/nnpfs/linux/nnpfs_inodeops.c2010-07-11 17:18:26.572458961 +0200
< at >< at > -48,7 +48,7 < at >< at >
 #include <asm/fcntl.h>
 
 #ifdef RCSID
-RCSID("$Id: nnpfs_inodeops.c,v 1.223 2006/12/11 16:35:26 tol Exp $");
+RCSID("$Id: nnpfs_inodeops.c,v 1.224 2008/03/08 21:40:10 tol Exp $");
 #endif
 
 static int
< at >< at > -105,7 +105,11 < at >< at > nnpfs_vma_close (struct vm_area_struct *
 }
 
 static struct vm_operations_struct nnpfs_file_vm_ops = {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
     .nopage= filemap_nopage,
+#else
+    .fault      = filemap_fault,
+#endif
     .close= nnpfs_vma_close,
 };
 
< at >< at > -134,12 +138,14 < at >< at > nnpfs_print_path(struct dentry *dentry)
  *
  */
 
+#if 0
 void
 nnpfs_print_lock(char *s, struct semaphore *sem)
 {
     NNPFSDEB(XDEBLOCK, ("lock: %s sem: %p count: %d\n",
       s, sem, (int)atomic_read(&sem->count)));
 }
+#endif
 
 /*
  *
< at >< at > -240,7 +246,11 < at >< at > nnpfs_lookup (struct inode *dir, struct 
 
 msg.header.opcode = NNPFS_MSG_GETNODE;
         
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 msg.cred.pag = nnpfs_get_pag();
 msg.parent_handle = d->handle;
         
< at >< at > -310,7 +320,11 < at >< at > nnpfs_open_valid(struct inode *vp, u_int
       {
 struct nnpfs_message_open msg;
 msg.header.opcode = NNPFS_MSG_OPEN;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 msg.cred.pag = nnpfs_get_pag();
 msg.handle = xn->handle;
 msg.tokens = tok;
< at >< at > -425,7 +439,11 < at >< at > nnpfs_fsync_int(struct file *file, u_int
 
 msg.header.opcode = NNPFS_MSG_PUTDATA;
 msg.cred.pag = nnpfs_get_pag();
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 msg.handle = xn->handle;
 msg.flag   = flag;
 msg.offset = off;
< at >< at > -460,9 +478,17 < at >< at > nnpfs_fsync_int(struct file *file, u_int
  *
  */
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
 static int
 nnpfs_fsync(struct file *file, struct dentry *dentry, int datasync)
+#else
+static int
+nnpfs_fsync(struct file *file, int datasync)
+#endif
 {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
+    struct dentry *dentry = file->f_path.dentry;
+#endif
     struct inode *inode = DENTRY_TO_INODE(dentry);
     struct nnpfs *nnpfsp;
     struct nnpfs_node *xn;
< at >< at > -511,7 +537,11 < at >< at > nnpfs_attr_valid(struct inode * vp, u_in
             struct nnpfs_message_getattr msg;
 
             msg.header.opcode = NNPFS_MSG_GETATTR;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
             msg.cred.uid = current->uid;
+#else
+            msg.cred.uid = current_uid();
+#endif
             msg.cred.pag = pag;
             msg.handle = xn->handle;
             error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
< at >< at > -551,7 +581,11 < at >< at > nnpfs_rights_valid(struct inode * vp, nn
             struct nnpfs_message_getattr msg;
 
             msg.header.opcode = NNPFS_MSG_GETATTR;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
             msg.cred.uid = current->uid;
+#else
+            msg.cred.uid = current_uid();
+#endif
             msg.cred.pag = pag;
             msg.handle = xn->handle;
             error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
< at >< at > -592,8 +626,13 < at >< at > check_rights (nnpfs_rights rights, int m
  * We don't hold i_mutex.
  */
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
 static int
 nnpfs_permission(struct inode *inode, int mode, struct nameidata *nd)
+#else
+static int
+nnpfs_permission(struct inode *inode, int mode)
+#endif
 {
     int error = 0;
     nnpfs_pag_t pag = nnpfs_get_pag();
< at >< at > -636,7 +675,11 < at >< at > nnpfs_do_getdata(struct nnpfs_node *xn, 
     int error;
 
     msg.header.opcode = NNPFS_MSG_GETDATA;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     msg.cred.uid = current->uid;
+#else
+    msg.cred.uid = current_uid();
+#endif
     msg.cred.pag = nnpfs_get_pag();
     msg.handle = xn->handle;
     msg.tokens = tok;
< at >< at > -903,9 +946,17 < at >< at > nnpfs_create(struct inode *dir, struct d
     XA_CLEAR(&msg.attr);
     XA_SET_MODE(&msg.attr, mode);
     XA_SET_TYPE(&msg.attr, NNPFS_FILE_REG);
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     XA_SET_GID(&msg.attr, current->fsgid);
+#else
+    XA_SET_GID(&msg.attr, current_fsgid());
+#endif
     msg.mode = 0;/* XXX */
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     msg.cred.uid = current->uid;
+#else
+    msg.cred.uid = current_uid();
+#endif
     msg.cred.pag = nnpfs_get_pag();
     error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
     if (error == 0)
< at >< at > -946,7 +997,11 < at >< at > nnpfs_unlink (struct inode * dir, struct
     if (strlcpy(msg.name, dentry->d_name.name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
 return -ENAMETOOLONG;
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     msg.cred.uid = current->uid;
+#else
+    msg.cred.uid = current_uid();
+#endif
     msg.cred.pag = nnpfs_get_pag();
     error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
     if (error == 0)
< at >< at > -991,7 +1046,11 < at >< at > nnpfs_rename (struct inode * old_dir, st
     if (strlcpy(msg.new_name, new_dentry->d_name.name, sizeof(msg.new_name)) >= NNPFS_MAX_NAME)
 return -ENAMETOOLONG;
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     msg.cred.uid = current->uid;
+#else
+    msg.cred.uid = current_uid();
+#endif
     msg.cred.pag = nnpfs_get_pag();
     error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
     if (error == 0)
< at >< at > -1040,9 +1099,17 < at >< at > nnpfs_mkdir(struct inode * dir, struct d
 XA_CLEAR(&msg.attr);
 XA_SET_MODE(&msg.attr, mode);
 XA_SET_TYPE(&msg.attr, NNPFS_FILE_DIR);
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 XA_SET_GID(&msg.attr, current->fsgid);
+#else
+        XA_SET_GID(&msg.attr, current_fsgid());
+#endif
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 msg.cred.pag = nnpfs_get_pag();
 error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
 if (error == 0)
< at >< at > -1083,7 +1150,11 < at >< at > nnpfs_rmdir(struct inode * dir, struct d
     msg.parent_handle = xn->handle;
     if (strlcpy(msg.name, dentry->d_name.name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
     return -ENAMETOOLONG;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     msg.cred.uid = current->uid;
+#else
+    msg.cred.uid = current_uid();
+#endif
     msg.cred.pag = nnpfs_get_pag();
     error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
     if (error == 0)
< at >< at > -1128,7 +1199,11 < at >< at > static int nnpfs_link(struct dentry *old
 if (strlcpy(msg.name, name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
     return -ENAMETOOLONG;
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 msg.cred.pag = nnpfs_get_pag();
 error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
 if (error == 0)
< at >< at > -1157,29 +1232,47 < at >< at > static int nnpfs_symlink(struct inode *d
     xn = VNODE_TO_XNODE(dir);
 
     {
-struct nnpfs_message_symlink msg;
+struct nnpfs_message_symlink *msg = NULL;
 
-msg.header.opcode = NNPFS_MSG_SYMLINK;
-msg.parent_handle = xn->handle;
-if (strlcpy(msg.name, name, sizeof(msg.name)) >= NNPFS_MAX_NAME)
-    return -ENAMETOOLONG;
-if (strlcpy(msg.contents, symname, sizeof(msg.contents)) >= NNPFS_MAX_SYMLINK_CONTENT)
-    return -ENAMETOOLONG;
-XA_CLEAR(&msg.attr);
-XA_SET_MODE(&msg.attr, 0777);
-XA_SET_TYPE(&msg.attr, NNPFS_FILE_LNK);
-XA_SET_GID(&msg.attr, current->fsgid);
+msg = kmalloc(sizeof(struct nnpfs_message_symlink), GFP_KERNEL);
 
-msg.cred.uid = current->uid;
-msg.cred.pag = nnpfs_get_pag();
-error = nnpfs_message_rpc(nnpfsp, &msg.header, sizeof(msg));
+if (!msg)
+  return -ENOMEM;
+
+msg->header.opcode = NNPFS_MSG_SYMLINK;
+msg->parent_handle = xn->handle;
+if (strlcpy(msg->name, name, sizeof(msg->name)) >= NNPFS_MAX_NAME) {
+  kfree(msg);
+  return -ENAMETOOLONG;
+}
+if (strlcpy(msg->contents, symname, sizeof(msg->contents)) >= NNPFS_MAX_SYMLINK_CONTENT) {
+  kfree(msg);
+  return -ENAMETOOLONG;
+}
+XA_CLEAR(&msg->attr);
+XA_SET_MODE(&msg->attr, 0777);
+XA_SET_TYPE(&msg->attr, NNPFS_FILE_LNK);
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
+XA_SET_GID(&msg->attr, current->fsgid);
+#else
+        XA_SET_GID(&msg->attr, current_fsgid());
+#endif
+
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
+msg->cred.uid = current->uid;
+#else
+        msg->cred.uid = current_uid();
+#endif
+msg->cred.pag = nnpfs_get_pag();
+error = nnpfs_message_rpc(nnpfsp, &msg->header, sizeof(struct nnpfs_message_symlink));
 if (error == 0)
-    error = NNPFS_MSG_WAKEUP_ERROR(&msg);
+    error = NNPFS_MSG_WAKEUP_ERROR(msg);
 
 /* XXX should this really be here */
 if (DENTRY_TO_XDENTRY(dentry)->xd_flags == 0) {
     printk(KERN_EMERG "NNPFS Panic: nnpfs_symlink: dentry not valid\n");
 }
+kfree(msg);
     }
 
     return error;
< at >< at > -1398,7 +1491,11 < at >< at > nnpfs_setattr (struct dentry *dentry, st
         struct nnpfs_message_putattr msg;
 
         msg.header.opcode = NNPFS_MSG_PUTATTR;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
 msg.cred.uid = current->uid;
+#else
+        msg.cred.uid = current_uid();
+#endif
 msg.cred.pag = nnpfs_get_pag();
         msg.handle = xn->handle;
         nnpfs_iattr2attr(xn, attr, &msg.attr);
< at >< at > -1545,6 +1642,8 < at >< at > nnpfs_d_delete(struct dentry *dentry)
     return 0;
 }
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
+
 static ssize_t
 nnpfs_sendfile(struct file *file, loff_t *ppos, size_t count,
        read_actor_t actor, void *target)
< at >< at > -1568,6 +1667,33 < at >< at > nnpfs_sendfile(struct file *file, loff_t
     return error;
 }
 
+#else
+
+static ssize_t
+nnpfs_splice_read(struct file *file, loff_t *ppos,
+  struct pipe_inode_info *pipe, size_t count,
+  unsigned int flags)
+{
+    int error = 0;
+    struct inode *inode = file->f_dentry->d_inode;
+    struct nnpfs_node *xn = VNODE_TO_XNODE(inode);
+    
+    if (xn != NULL)
+NNPFSDEB(XDEBVNOPS, ("nnpfs_sendfile: tokens: 0x%x\n", xn->tokens));
+
+    error = nnpfs_data_valid(inode, NNPFS_DATA_R, *ppos, *ppos + count);
+    if (error) {
+NNPFSDEB(XDEBVNOPS, ("nnpfs_sendfile: data not valid %d\n", error));
+return error;
+    }
+    error = file->f_op->splice_read(file, ppos, pipe, count, flags);
+
+    NNPFSDEB(XDEBVNOPS, ("nnpfs_sendfile: error = %d\n", error));
+    return error;
+}
+
+#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23) */
+
 /*
  *
  *
< at >< at > -1639,11 +1765,15 < at >< at > nnpfs_write_backpage(struct page *page, 
 struct address_space *mapping = backfile->f_mapping;
 unsigned len = PAGE_CACHE_SIZE;
 struct page *backpage;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
+void *fsdata;
+#endif
 unsigned long offset;
 
 int error;
 
 do {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 backpage = grab_cache_page(mapping, nnpfs_get_backindex(page));
 if (!backpage) {
 printk("nnpfs_write_backpage: no page\n");
< at >< at > -1652,21 +1782,36 < at >< at > nnpfs_write_backpage(struct page *page, 
 
 error = mapping->a_ops->prepare_write(backfile, backpage,
       0, len);
+#else
+error = pagecache_write_begin(backfile, mapping, 0, len,
+AOP_FLAG_UNINTERRUPTIBLE, &backpage, &fsdata);
+#endif
 if (!error) {
 copy_highpage(backpage, page);
 flush_dcache_page(backpage);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 error = mapping->a_ops->commit_write(backfile, backpage,
      0, len);
+#else
+error = pagecache_write_end(backfile, mapping, 0, len,
+len, backpage, fsdata);
+if (error > 0)
+error = 0;
+#endif
 }
 if (error == AOP_TRUNCATED_PAGE) {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 page_cache_release(backpage);
+#endif
 continue;
 }
 } while (0);
 
 offset = page_offset(backpage);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 unlock_page(backpage);
 page_cache_release(backpage);
+#endif
 
 if (error)
 printk("nnpfs_write_backpage: EIO\n");
< at >< at > -1872,6 +2017,34 < at >< at > nnpfs_prepare_write(struct file *file, s
 return ret;
 }
 
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+
+static int
+nnpfs_write_begin(struct file *file, struct address_space *mapping, loff_t pos,
+unsigned len, unsigned flags, struct page **pagep, void **fsdata)
+{
+struct page *page;
+pgoff_t index;
+unsigned from;
+
+index = pos >> PAGE_CACHE_SHIFT;
+from = pos & (PAGE_CACHE_SIZE - 1);
+
+#ifndef AOP_FLAG_NOFS
+page = __grab_cache_page(mapping, index);
+#else
+page = grab_cache_page_write_begin(mapping, index, flags);
+#endif
+if (!page)
+return -ENOMEM;
+
+*pagep = page;
+
+return nnpfs_prepare_write(file, page, from, from+len);
+}
+
+#endif
+
 static int
 nnpfs_commit_write(struct file *file, struct page *page, unsigned from, unsigned to)
 {
< at >< at > -1902,14 +2075,45 < at >< at > nnpfs_commit_write(struct file *file, st
     return 0;
 }
 
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+
+static int
+nnpfs_write_end(struct file *file, struct address_space *mapping, loff_t pos,
+unsigned len, unsigned copied, struct page *page, void *fsdata)
+{
+unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+
+/* zero the stale part of the page if we did a short copy */
+if (copied < len) {
+void *kaddr = kmap_atomic(page, KM_USER0);
+memset(kaddr + from + copied, 0, len - copied);
+flush_dcache_page(page);
+kunmap_atomic(kaddr, KM_USER0);
+}
+
+nnpfs_commit_write(file, page, from, from+copied);
+
+unlock_page(page);
+page_cache_release(page);
+
+return copied;
+}
+
+#endif
+
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
 const
 #endif
 struct address_space_operations nnpfs_aops = {
 .readpage = nnpfs_readpage,
 .writepage = nnpfs_writepage,
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
 .prepare_write = nnpfs_prepare_write,
 .commit_write = nnpfs_commit_write,
+#else
+.write_begin = nnpfs_write_begin,
+.write_end = nnpfs_write_end,
+#endif
 };
 
 /*
< at >< at > -1924,7 +2128,11 < at >< at > struct file_operations nnpfs_file_operat
     .flush= nnpfs_flush,
     .release= nnpfs_release_file,
     .fsync= nnpfs_fsync,
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
     .sendfile= nnpfs_sendfile,
+#else
+    .splice_read = nnpfs_splice_read,
+#endif
 };
 
 struct file_operations nnpfs_dead_operations = {
diff -uprN arla-0.90/nnpfs/linux/nnpfs_message.c arla-0.90-new/nnpfs/linux/nnpfs_message.c
--- arla-0.90/nnpfs/linux/nnpfs_message.c2007-01-09 17:33:31.000000000 +0100
+++ arla-0.90-new/nnpfs/linux/nnpfs_message.c2010-07-11 17:18:26.572458961 +0200
< at >< at > -45,7 +45,7 < at >< at >
 #include <linux/mount.h>
 
 #ifdef RCSID
-RCSID("$Id: nnpfs_message.c,v 1.143.2.1 2007/01/09 16:33:31 tol Exp $");
+RCSID("$Id: nnpfs_message.c,v 1.143 2006/12/11 16:40:24 tol Exp $");
 #endif
 
 static void
< at >< at > -605,12 +605,10 < at >< at > gc_block(struct nnpfs *nnpfsp,
     }
 
     if (!nnpfs_block_have_p(xn, offset)) {
-#if 0   /* happens when daemon sends several messages for same block */
 printk(KERN_EMERG "NNPFS/gc_block: "
        "ENOENT (%d,%d,%d,%d) 0x%llx\n", 
        xn->handle.a, xn->handle.b, xn->handle.c, xn->handle.d, 
        (unsigned long long)offset);
-#endif
 return -ENOENT;
     }
 
< at >< at > -737,12 +735,23 < at >< at > nnpfs_message_version(struct nnpfs *nnpf
    "nnpfs_message_version failed path_lookup, "
    "errno: %d\n", error);
 } else {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
     nnpfsp->cacheroot = mntget(nd.mnt);
     nnpfsp->cachedir = dget(nd.dentry);
     path_release(&nd);
+#else
+    nnpfsp->cacheroot = mntget(nd.path.mnt);
+    nnpfsp->cachedir = dget(nd.path.dentry);
+    path_put(&nd.path);
+#endif
     
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     nnpfsp->uid = current->fsuid;
     nnpfsp->gid = current->fsgid;
+#else
+            nnpfsp->uid = current_fsuid();
+            nnpfsp->gid = current_fsgid();
+#endif
 
     /* XXX we should validate these values */
     nnpfs_blocksize = blocksize;
diff -uprN arla-0.90/nnpfs/linux/nnpfs_syscalls.c arla-0.90-new/nnpfs/linux/nnpfs_syscalls.c
--- arla-0.90/nnpfs/linux/nnpfs_syscalls.c2007-01-03 15:26:27.000000000 +0100
+++ arla-0.90-new/nnpfs/linux/nnpfs_syscalls.c2010-07-11 18:49:01.229639299 +0200
< at >< at > -147,10 +147,16 < at >< at > static int nnpfs_sec_registered = 0;
 #define SEC2PAG(s) (nnpfs_pag_t)(unsigned long)(s)
 #define PAG2SEC(p) (void *)(unsigned long)(p)
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
+
 static int
 nnpfs_sec_task_alloc(struct task_struct *p)
 {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     nnpfs_pag_t pag = SEC2PAG(current->security);
+#else
+    nnpfs_pag_t pag = SEC2PAG(current_security());
+#endif
     if (pag)
 p->security = PAG2SEC(pag);
     return 0;
< at >< at > -164,35 +170,55 < at >< at > nnpfs_sec_task_free(struct task_struct *
 p->security = NULL;
 }
 
+#endif
+
 static nnpfs_pag_t
 nnpfs_get_pag_sec(void)
 {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     nnpfs_pag_t pag = SEC2PAG(current->security);
+#else
+    nnpfs_pag_t pag = SEC2PAG(current_security());
+#endif
     if (pag)
 return pag;
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     return current->uid;
+#else
+    return current_uid();
+#endif
 }
 
 static int
 nnpfs_set_pag_sec(void)
 {
     static nnpfs_pag_t pagnum = NNPFS_PAG_LLIM;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
+    struct cred *cred;
+#endif
 
     if (pagnum == NNPFS_PAG_ULIM)
 return -ENOMEM;
     /* pagnum = NNPFS_PAG_LLIM; */
     
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     current->security = PAG2SEC(pagnum);
+#else
+    cred = (struct cred *) current->cred;
+    cred->security = PAG2SEC(pagnum);
+#endif
     pagnum++;
     return 0;
 }
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 static struct security_operations nnpfs_sec_ops = {
     .task_alloc_security = nnpfs_sec_task_alloc,
     .task_free_security = nnpfs_sec_task_free,
 //    .task_reparent_to_init = nnpfs_sec_reparent_to_init,
 };
+#endif
 
 #endif /* CONFIG_SECURITY */
 
< at >< at > -222,11 +248,18 < at >< at > find_pag(struct group_info *gi)
 static nnpfs_pag_t
 nnpfs_get_pag_group(void)
 {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     struct group_info *gi = current->group_info;
     nnpfs_pag_t ret = current->uid;
+#else
+    struct group_info *gi = get_current_groups();
+    nnpfs_pag_t ret = current_uid();
+#endif
     int i;
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     get_group_info(gi);
+#endif
 
     i = find_pag(gi);
     if (i != NNPFS_PAG_NOTFOUND)
< at >< at > -242,13 +275,23 < at >< at > nnpfs_get_pag_group(void)
 static int
 store_pag(nnpfs_pag_t pagnum)
 {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     struct group_info *old_gi = current->group_info;
+#else
+   struct group_info *old_gi = get_current_groups();
+#endif
     struct group_info *new_gi;
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
     int nblocks, count;
+#else
+    unsigned int nblocks, count;
+#endif
     int found = 0;
     int i, k;
     
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)    
     get_group_info(old_gi);
+#endif
 
     i = find_pag(old_gi);
     if (i != NNPFS_PAG_NOTFOUND)
< at >< at > -317,7 +360,11 < at >< at > nnpfs_get_pag()
     return nnpfs_get_pag_group();
 #endif /* GROUPPAGS */
 
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     return current->uid;
+#else
+    return current_uid();
+#endif
 }
 
 static inline int
< at >< at > -528,7 +575,11 < at >< at > user_path2dentry (struct nameidata *nd, 
     putname(kname);
     if (error)
 return ERR_PTR(error);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
     return nd->dentry;
+#else
+    return nd->path.dentry;
+#endif
 }
 
 asmlinkage long
< at >< at > -540,11 +591,16 < at >< at > sys_afs_int (int operation,
 {
     long error = 0;
     struct arlaViceIoctl vice_ioctl; 
-    struct nnpfs_message_pioctl msg;
+    struct nnpfs_message_pioctl *msg = NULL;
     struct nnpfs_message_wakeup *msg2;
     struct dentry *dentry = NULL;
     struct nameidata nd;
-    
+
+    msg = kmalloc(sizeof(struct nnpfs_message_pioctl), GFP_KERNEL);
+
+    if (!msg)
+      return -ENOMEM;
+
     lock_kernel();
 
     NNPFSDEB(XDEBSYS, ("sys_afs kernel locked\n"));
< at >< at > -575,7 +631,7 < at >< at > sys_afs_int (int operation,
     goto unlock;
 }
 if (vice_ioctl.in_size != 0) {
-    if(copy_from_user(&msg.msg,
+    if(copy_from_user(&msg->msg,
       vice_ioctl.in,
       vice_ioctl.in_size) != 0) {
 error = -EFAULT;
< at >< at > -628,19 +684,23 < at >< at > sys_afs_int (int operation,
 error = -EINVAL;
 goto unlock;
     }
-    msg.handle = xn->handle;
+    msg->handle = xn->handle;
 }
 
-msg.header.opcode = NNPFS_MSG_PIOCTL;
-msg.opcode = a_opcode;
+msg->header.opcode = NNPFS_MSG_PIOCTL;
+msg->opcode = a_opcode;
 
-msg.insize   = vice_ioctl.in_size;
-msg.outsize  = vice_ioctl.out_size;
-msg.cred.uid = current->uid;
-msg.cred.pag = nnpfs_get_pag();
+msg->insize   = vice_ioctl.in_size;
+msg->outsize  = vice_ioctl.out_size;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
+msg->cred.uid = current->uid;
+#else
+        msg->cred.uid = current_uid();
+#endif
+msg->cred.pag = nnpfs_get_pag();
 
-error = nnpfs_message_rpc(&nnpfs[0], &msg.header, sizeof(msg)); /* XXX */
-msg2 = (struct nnpfs_message_wakeup *) &msg;
+error = nnpfs_message_rpc(&nnpfs[0], &msg->header, sizeof(struct nnpfs_message_pioctl)); /* XXX */
+msg2 = (struct nnpfs_message_wakeup *) msg;
 if (error == 0)
     error = msg2->error;
 
< at >< at > -675,11 +735,16 < at >< at > sys_afs_int (int operation,
     
  unlock:
     if (dentry)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 path_release(&nd);
+#else
+path_put(&nd.path);
+#endif
 
     NNPFSDEB(XDEBSYS, ("nnpfs_syscall returns error: %ld\n", error));
 
     NNPFSDEB(XDEBSYS, ("sys_afs kernel unlock\n"));
+    kfree(msg);
     unlock_kernel();
 
     return error;
< at >< at > -780,20 +845,32 < at >< at > static int nnpfs_init_procfs(void)
 {
     struct proc_dir_entry *entry;
     
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
     nnpfs_procfs_dir = proc_mkdir(NNPFS_PROC_DIR, proc_root_fs);
+#else
+    nnpfs_procfs_dir = proc_mkdir("fs/" NNPFS_PROC_DIR, NULL);
+#endif
     if (nnpfs_procfs_dir == NULL)
 return -ENOMEM;
     
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
     nnpfs_procfs_dir->owner = THIS_MODULE;
+#endif
     
     entry = create_proc_entry(NNPFS_PROC_NODE, 0666, nnpfs_procfs_dir);
     if (entry == NULL) {
 NNPFSDEB(XDEBSYS, ("nnpfs_init_procfs: no node\n"));
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
 remove_proc_entry(NNPFS_PROC_DIR, proc_root_fs);
+#else
+remove_proc_entry("fs/" NNPFS_PROC_DIR, NULL);
+#endif
 return -ENOMEM;
     }
     
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
     entry->owner = THIS_MODULE;
+#endif
     entry->proc_fops = &nnpfs_procfs_fops;
 
 #ifdef SYSCALLCOMPAT
< at >< at > -815,7 +892,11 < at >< at > static void nnpfs_exit_procfs(void)
     }
 #endif /* SYSCALLCOMPAT */
     remove_proc_entry(NNPFS_PROC_NODE, nnpfs_procfs_dir);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
     remove_proc_entry(NNPFS_PROC_DIR, proc_root_fs);
+#else
+    remove_proc_entry("fs/" NNPFS_PROC_DIR, NULL);
+#endif
 }
 
 #ifdef GROUPPAGS
< at >< at > -840,12 +921,14 < at >< at > void
 install_afs_syscall(void)
 {
 #ifdef CONFIG_SECURITY
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
     if (register_security(&nnpfs_sec_ops))
 NNPFSDEB(XDEBSYS,
  ("install_afs_syscall: nnpfs_init_sec failed\n"));
     else
 nnpfs_sec_registered = 1;
 #endif
+#endif
 
     nnpfs_init_procfs();
 
< at >< at > -888,9 +971,11 < at >< at > restore_afs_syscall (void)
 #endif /* SYSCALLHACK */
 
 #ifdef CONFIG_SECURITY
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
     if (nnpfs_sec_registered)
 if (unregister_security(&nnpfs_sec_ops))
     printk(KERN_EMERG "nnpfs_exit_sec: couldn't unregister\n");
+#endif
 #endif /* !CONFIG_SECURITY */
 
 #ifdef GROUPPAGS
diff -uprN arla-0.90/nnpfs/linux/nnpfs_syscalls-lossage.c arla-0.90-new/nnpfs/linux/nnpfs_syscalls-lossage.c
--- arla-0.90/nnpfs/linux/nnpfs_syscalls-lossage.c2006-12-11 17:31:45.000000000 +0100
+++ arla-0.90-new/nnpfs/linux/nnpfs_syscalls-lossage.c2010-07-11 17:18:26.572458961 +0200
< at >< at > -63,6 +63,11 < at >< at > const char * __attribute__((weak))
     unsigned long *offset,
     char **modname, char *namebuf);
 
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18)
+#ifdef __x86_64__
+extern rwlock_t tasklist_lock __attribute__((weak));
+#endif
+#endif
 static void **
 get_start_addr(void) {
 #ifdef __x86_64__
diff -uprN arla-0.90/nnpfs/linux/nnpfs_vfsops.c arla-0.90-new/nnpfs/linux/nnpfs_vfsops.c
--- arla-0.90/nnpfs/linux/nnpfs_vfsops.c2006-12-11 17:43:35.000000000 +0100
+++ arla-0.90-new/nnpfs/linux/nnpfs_vfsops.c2010-07-11 17:18:26.577958688 +0200
< at >< at > -49,9 +49,13 < at >< at > RCSID("$Id: nnpfs_vfsops.c,v 1.109 2006/
 
 struct nnpfs nnpfs[NNNPFS];
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 static void nnpfs_read_inode(struct inode *inode);
+#endif
 static void nnpfs_put_super(struct super_block *sb);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 static void nnpfs_put_inode(struct inode *inode);
+#endif
 static void nnpfs_write_super(struct super_block * sb);
 
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
< at >< at > -61,8 +65,10 < at >< at > static int nnpfs_statfs(struct super_blo
 #endif
 
 static struct super_operations nnpfs_sops = { 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
     read_inode: nnpfs_read_inode,
     put_inode: nnpfs_put_inode,
+#endif
     alloc_inode: nnpfs_node_alloc,
     destroy_inode: nnpfs_node_free,
     drop_inode: generic_delete_inode,
< at >< at > -189,7 +195,11 < at >< at > nnpfs_read_super (struct super_block * s
 if (error)
     ddev = ERR_PTR(error);
 else
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
     ddev = nd.dentry;
+#else
+    ddev = nd.path.dentry;
+#endif
 
 if (!IS_ERR(ddev)) {
     minordevice = MINOR(ddev->d_inode->i_rdev);
< at >< at > -273,6 +283,7 < at >< at > nnpfs_put_super(struct super_block *sb)
     NNPFSDEB(XDEBVFOPS, ("nnpfs_put_super exiting\n"));
 }
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 static void
 nnpfs_read_inode(struct inode *inode)
 {
< at >< at > -339,6 +350,7 < at >< at > nnpfs_put_inode(struct inode *inode)
 
     up(&nnpfsp->inactive_sem);
 }
+#endif // LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 
 static int
 nnpfs_statfs_int(struct super_block *sb, struct kstatfs *buf)
< at >< at > -352,7 +364,15 < at >< at > nnpfs_statfs_int(struct super_block *sb,
     tmp.f_bavail  = 1024*1024*2-50;
     tmp.f_files   = 1024*1024;
     tmp.f_ffree   = 1024*1024-100;
+    tmp.f_fsid.val[0] = 0;
+    tmp.f_fsid.val[1] = 0;
     tmp.f_namelen = NAME_MAX;
+    tmp.f_frsize  = 0;
+    tmp.f_spare[0] = 0;
+    tmp.f_spare[1] = 0;
+    tmp.f_spare[2] = 0;
+    tmp.f_spare[3] = 0;
+    tmp.f_spare[4] = 0;
     *buf = tmp;
     return 0;
 }
_______________________________________________
Arla-drinkers mailing list
Arla-drinkers< at >stacken.kth.se
https://lists.stacken.kth.se/mailman/listinfo/arla-drinkers

Re: SV: PATCH: Arla CVS Current on Linux 2.6.24-2.6.35-rc1

Bo Brantén — 2010-07-11T16:29:38


Yes, the reference count is decremented with put_group_info() but it is 
two possible ways to fix it, I think the second one is the most correct:

nnpfs_get_pag_group(void)
{
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     struct group_info *gi = current->group_info;
     nnpfs_pag_t ret = current->uid;
#else
     struct group_info *gi = get_current_groups();
     nnpfs_pag_t ret = current_uid();
#endif
     int i;

     get_group_info(gi);

     i = find_pag(gi);
     if (i != NNPFS_PAG_NOTFOUND)
         ret = GROUP_AT(gi, i);

     put_group_info(gi);
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,28)
     put_group_info(gi);
#endif

     NNPFSDEB(XDEBSYS, ("nnpfs_get_pag_group: returning %u\n", ret));
     return ret;
}

nnpfs_get_pag_group(void)
{
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     struct group_info *gi = current->group_info;
     nnpfs_pag_t ret = current->uid;
#else
     struct group_info *gi = get_current_groups();
     nnpfs_pag_t ret = current_uid();
#endif
     int i;

#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,28)
     get_group_info(gi);
#endif

     i = find_pag(gi);
     if (i != NNPFS_PAG_NOTFOUND)
         ret = GROUP_AT(gi, i);

     put_group_info(gi);

     NNPFSDEB(XDEBSYS, ("nnpfs_get_pag_group: returning %u\n", ret));
     return ret;
}

Bo Branten