Morales, Ana | 23 Aug 01:21 2011
Picon

FW: Looking for AFS Information

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
Morales, Ana | 22 Aug 17:43 2011
Picon

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
Mykyta Yevstifeyev | 31 Mar 16:51 2011
Picon

AFS and 'afs' URI scheme

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
Derrick Brashear | 23 Mar 16:10 2011

AFS & Kerberos Best Practices Workshop 2011: Registration available and other details

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
Derrick Brashear | 3 Mar 16:19 2011

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

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
Derrick Brashear | 4 Feb 01:22 2011

CFP: AFS & Kerberos Best Practices Workshop 2011

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
Kim Kimball | 24 Aug 22:24 2010

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

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:
> IMPORTANT:
> This has gotten fairly lengthy, but please read through to the end.  
> This message contains important information on the future of AFS 
> protocol standardization work, and a specific request for input from 
> the AFS community (that is, YOUR input) within the next 2 weeks.
>
> PLEASE send followups to afs3-standardization <at> openafs.org
>
>
> Back in January of 2006, the afs3-standardization <at> openafs.org mailing 
> list was created in order to provide a forum for discussion of the AFS 
> protocols and particularly to coordinate extensions and changes to 
> those protocols among the various implementations.  The first 
> discussions in that vein started the following month, with Jeffrey 
> Altman's proposal to define new GetCapabilities RPC's for each of the 
> various RPC services.  Since then, there have been discussions on a 
> wide variety of proposed extensions, some small and some much larger 
> in scope.  Overall, I consider the mailing list to have been and 
> continue to be a success.
>
> Two years ago, at the AFS & Kerberos Best Practices Workshop at NJIT 
> in Newark, NJ, there was some discussion about the prospect of 
> establishing a more formal charter and process for the standardization 
> group, and especially of insuring its independence from any one 
> implementation.  After the workshop, Simon Wilkinson took a stab at 
> writing such a charter, and sent his proposal to the 
> afs3-standardization mailing list (see Simon's message to that list, 
> dated 15-Jul-2008).  This prompted quite a lot of discussion and two 
> additional drafts over following couple of months. After the third 
> draft, there was exactly one additional comment, and there has been no 
> further discussion since.
>
> It is my personal belief that there was general agreement within the 
> community to move forward with Simon's draft as an initial charter for 
> the standardization group.  However, there has been little progress in 
> the last 21 months.  Much of this is my fault -- I kept saying I was 
> going to do something and then not getting around to it.  However, 
> while the document hasn't been discussed much in the interim, my 
> conversations during that time with various individuals, in person and 
> online, lead me to believe that there is _still_ general agreement to 
> proceed with Simon's draft.
>
>
>
> So, here's what I'm going to do about it...
>
> Simon's document calls for a bootstrapping process in which a 
> registrar group is form of the then-current registrar (myself) plus 
> one representative from each current implementation (IBM, OpenAFS, 
> kAFS, Arla) that cares to provide one.  The registrars would then 
> serve as vote-takers in an initial election of two chairs as described 
> in section 2.2.2 of the draft.
>
> The initial bootstrapping of the registrars has already mostly taken 
> place. Thomas Kula has agreed to serve as a registrar representing 
> OpenAFS, and has held that position officially since the 2009 
> workshop.  Around that time, I asked IBM, kAFS, and Arla to nominate 
> registrars, but I have yet to receive a response that resulted in an 
> actual volunteer.  If any of those organizations wants to nominate 
> someone, please contact me.  Otherwise, Thomas and I have already 
> agreed that we will nonetheless increase the size of the registrar 
> group to at least three and seek out a volunteer to fill the vacant 
> position.  It is my hope that we can accomplish that by the end of the 
> month.
>
> The next step would seem to be the bootstrapping of the chairs.  
> However, we have a recursive-dependency problem here -- before we can 
> use the election process defined in Simon's document with any 
> confidence, we must be sure we have consensus among the community to 
> use that document. However, lacking a chair, there is no formal means 
> of determining consensus.
> Chicken, meet Egg.
>
> Simon's document itself proposes part of the solution to this problem, 
> in the form of the last paragraph of section 3, which calls on the 
> newly-formed group to develop, adopt, and publish its own charter.  To 
> complete the solution, the registrars note that the first step 
> (indeed, the first several steps) in electing new chairs rest on our 
> hands.  Thus, we are taking the following actions:
>
>
> (1) I have asked Simon to submit the latest version of his proposed 
> charter
>    in the form of an Internet-Draft.  That draft is now available at
> <http://tools.ietf.org/html/draft-wilkinson-afs3-standardisation-00>
>
> (2) On behalf of the registrars, I am issuing this consensus call.  This
>    is an attempt to elicit comments and to discover whether there is
>    rough consensus in the AFS community to begin formalizing the protocol
>    standards process as described in the draft named above.  I am asking
>    everyone to review the proposed charter and send any comments to the
>    mailing list, afs3-standardization <at> openafs.org, within the next 2
>    weeks.
>
> (3) On or shortly after Wednesday, July 21, 2010, the registrars will
>    examine the comments received and make a determination as to whether
>    we believe such a consensus exists.  Depending on the state affairs,
>    we may choose to wait a while longer for discussion to die down before
>    making a determination.  In other words, this is not a hard deadline;
>    it is only the earliest date on which we will make any decision.
>
> If at this point the registrars believe that there is not a rough 
> consensus to adopt Simon's draft charter and that no such consensus is 
> forthcoming, we will simply stop.  Things will continue as they are 
> today, with no formal process, unless or until someone tries again.
>
> However, if the registrars believe that a rough consensus _does_ 
> exist, we will more or less immediately begin the election process as 
> described in section 2.2.2, with the full set of registrars (at least 
> Thomas and myself, and preferably at least one other) serving as 
> vote-takers.  Our goal will be to follow the timeline set out in that 
> document.  However, this is incumbent on the community reaching a 
> consensus in time to start the election process no later than early 
> August.  If a consensus emerges, but more slowly, then we will adjust 
> the timeline accordingly.
>
>
> Here's the important bit again:
>
> Please take the time to review 
> draft-wilkinson-afs3-standardization-00.txt.
> Send your questions and comments to <afs3-standardization <at> openafs.org>.
> Please comment even if it's just to say "I support this" or "I oppose 
> this".
> Please send your comments in by Wednesday, July 21, 2010.
>
>
> -- Jeffrey T. Hutzelman (N3NHS) <jhutz+ <at> cmu.edu>
>   for the AFS Assigned Numbers Registrars
>
>
> _______________________________________________
> OpenAFS-info mailing list
> OpenAFS-info <at> openafs.org
> https://lists.openafs.org/mailman/listinfo/openafs-info
>
>
Bo Brantén | 12 Jul 00:26 2010
Picon
Picon
Picon

How to compile Arla on Mac OS


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$
Jeffrey Hutzelman | 8 Jul 01:08 2010
Picon

Consensus Call - AFS3-Standardization Charter

IMPORTANT:
This has gotten fairly lengthy, but please read through to the end.  This 
message contains important information on the future of AFS protocol 
standardization work, and a specific request for input from the AFS 
community (that is, YOUR input) within the next 2 weeks.

PLEASE send followups to afs3-standardization <at> openafs.org

Back in January of 2006, the afs3-standardization <at> openafs.org mailing list 
was created in order to provide a forum for discussion of the AFS protocols 
and particularly to coordinate extensions and changes to those protocols 
among the various implementations.  The first discussions in that vein 
started the following month, with Jeffrey Altman's proposal to define new 
GetCapabilities RPC's for each of the various RPC services.  Since then, 
there have been discussions on a wide variety of proposed extensions, some 
small and some much larger in scope.  Overall, I consider the mailing list 
to have been and continue to be a success.

Two years ago, at the AFS & Kerberos Best Practices Workshop at NJIT in 
Newark, NJ, there was some discussion about the prospect of establishing a 
more formal charter and process for the standardization group, and 
especially of insuring its independence from any one implementation.  After 
the workshop, Simon Wilkinson took a stab at writing such a charter, and 
sent his proposal to the afs3-standardization mailing list (see Simon's 
message to that list, dated 15-Jul-2008).  This prompted quite a lot of 
discussion and two additional drafts over following couple of months. After 
the third draft, there was exactly one additional comment, and there has 
been no further discussion since.

It is my personal belief that there was general agreement within the 
community to move forward with Simon's draft as an initial charter for the 
standardization group.  However, there has been little progress in the last 
21 months.  Much of this is my fault -- I kept saying I was going to do 
something and then not getting around to it.  However, while the document 
hasn't been discussed much in the interim, my conversations during that 
time with various individuals, in person and online, lead me to believe 
that there is _still_ general agreement to proceed with Simon's draft.

So, here's what I'm going to do about it...

Simon's document calls for a bootstrapping process in which a registrar 
group is form of the then-current registrar (myself) plus one 
representative from each current implementation (IBM, OpenAFS, kAFS, Arla) 
that cares to provide one.  The registrars would then serve as vote-takers 
in an initial election of two chairs as described in section 2.2.2 of the 
draft.

The initial bootstrapping of the registrars has already mostly taken place. 
Thomas Kula has agreed to serve as a registrar representing OpenAFS, and 
has held that position officially since the 2009 workshop.  Around that 
time, I asked IBM, kAFS, and Arla to nominate registrars, but I have yet to 
receive a response that resulted in an actual volunteer.  If any of those 
organizations wants to nominate someone, please contact me.  Otherwise, 
Thomas and I have already agreed that we will nonetheless increase the size 
of the registrar group to at least three and seek out a volunteer to fill 
the vacant position.  It is my hope that we can accomplish that by the end 
of the month.

The next step would seem to be the bootstrapping of the chairs.  However, 
we have a recursive-dependency problem here -- before we can use the 
election process defined in Simon's document with any confidence, we must 
be sure we have consensus among the community to use that document. 
However, lacking a chair, there is no formal means of determining consensus.
Chicken, meet Egg.

Simon's document itself proposes part of the solution to this problem, in 
the form of the last paragraph of section 3, which calls on the 
newly-formed group to develop, adopt, and publish its own charter.  To 
complete the solution, the registrars note that the first step (indeed, the 
first several steps) in electing new chairs rest on our hands.  Thus, we 
are taking the following actions:

(1) I have asked Simon to submit the latest version of his proposed charter
    in the form of an Internet-Draft.  That draft is now available at
    <http://tools.ietf.org/html/draft-wilkinson-afs3-standardisation-00>

(2) On behalf of the registrars, I am issuing this consensus call.  This
    is an attempt to elicit comments and to discover whether there is
    rough consensus in the AFS community to begin formalizing the protocol
    standards process as described in the draft named above.  I am asking
    everyone to review the proposed charter and send any comments to the
    mailing list, afs3-standardization <at> openafs.org, within the next 2
    weeks.

(3) On or shortly after Wednesday, July 21, 2010, the registrars will
    examine the comments received and make a determination as to whether
    we believe such a consensus exists.  Depending on the state affairs,
    we may choose to wait a while longer for discussion to die down before
    making a determination.  In other words, this is not a hard deadline;
    it is only the earliest date on which we will make any decision.

If at this point the registrars believe that there is not a rough consensus 
to adopt Simon's draft charter and that no such consensus is forthcoming, 
we will simply stop.  Things will continue as they are today, with no 
formal process, unless or until someone tries again.

However, if the registrars believe that a rough consensus _does_ exist, we 
will more or less immediately begin the election process as described in 
section 2.2.2, with the full set of registrars (at least Thomas and myself, 
and preferably at least one other) serving as vote-takers.  Our goal will 
be to follow the timeline set out in that document.  However, this is 
incumbent on the community reaching a consensus in time to start the 
election process no later than early August.  If a consensus emerges, but 
more slowly, then we will adjust the timeline accordingly.

Here's the important bit again:

Please take the time to review draft-wilkinson-afs3-standardization-00.txt.
Send your questions and comments to <afs3-standardization <at> openafs.org>.
Please comment even if it's just to say "I support this" or "I oppose this".
Please send your comments in by Wednesday, July 21, 2010.

-- Jeffrey T. Hutzelman (N3NHS) <jhutz+ <at> cmu.edu>
   for the AFS Assigned Numbers Registrars
Lubos Kejzlar | 7 Jul 11:46 2010
Picon

Register today for European AFS & Kerberos Conference 2010!

European AFS & Kerberos Conference 2010 is glad to invite you to register
for this year's event, which will take place in Pilsen, Czech Republic,
from September 13 to September 15. The conference is being hosted by Centre
for Information Technology, University of West Bohemia.

Presented topics include, but are not limited to:

    * AFS, Kerberos, LDAP and other related technologies
    * Performance tuning and benchmarking
    * Diagnostic, service monitoring and troubleshooting
    * Scalability and high availability issues
    * AFS/Kerberos & large scale, grid and cloud computing environments
    * Unique methods of AFS/Kerberos environment Backups
    * Web integration
    * Delegated administration and user management
    * Access control and related authorization services
    * Related tools for end-users, admins and programmers
    * Single Sign-On strategies
    * Cross cell/realm trust in real world
    * PKI and alternate security mechanism integration
    * AFS/Kerberos on the world globe: comparsion, interoperability,
      supplements, competitors and successors
    * Underlying OS, FS and hardware features
    * Work in progress, new features and future...

See the conference WWW pages at http://afs2010.civ.zcu.cz for further
details and breaking news.

Take advantage of the early registration rates, available until July 31.
Registration can be done online at http://afs2010.civ.zcu.cz/register/.

In addition to conference talks, following two half-day parallel tutorial
classes will be presented (separate registration available):

     * Setting-up your AFS cell
     * Advanced tuning & troubleshooting

Please be involved in tutorial's contents and take the exceptional
opportunity to customize it to fit your own needs! Create the "request
tickets" based on your (un)resolved trouble-issues you would like to help
explain (solve) or share with the community. The VIP developers and
administrators will do the best to be your guide... Please, read further
information and learn how to contribute on our Agenda-Tutorials web pages.

There are still some available agenda slots. Everyone is welcome to
share their experiences and ideas! Especially we are looking for talks
covering following areas:

    * AFS Tools for users, administrator and programmers
    * AFS in High Performance Computing environments

Submit your talk to afs2010 <at> civ.zcu.cz. The "Call for Participation"
will end Monday August 2, 2010. Acceptances will be made based upon
quality, applicability, and fit with other submissions.

Want be a sponsor? Sponsorship and contributor opportunities are still
available! For more info take a look at
http://afs2010.civ.zcu.cz/sponsorship.php or send us an e-mail.

We are looking forward to see you in Pilsen!

The Workshop Organizers,
http://afs2010.civ.zcu.cz/
afs2010 <at> civ.zcu.cz
Bo Brantén | 4 Jun 15:29 2010
Picon
Picon
Picon

PATCH: Arla CVS Current on Linux 2.6.24-2.6.32


Hello,

I have updated my patch for the latest kernels of Linux. It would be good 
if anyone with CVS access could commit this.

Bo Brantén
diff -uprN arla-cvs/nnpfs/linux/nnpfs_blocks.c arla-cvs-new/nnpfs/linux/nnpfs_blocks.c
--- arla-cvs/nnpfs/linux/nnpfs_blocks.c	2008-03-08 22:38:16.000000000 +0100
+++ arla-cvs-new/nnpfs/linux/nnpfs_blocks.c	2010-06-03 23:32:08.232611383 +0200
 <at>  <at>  -340,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>  -364,10 +368,21  <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;
+#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,
 <at>  <at>  -403,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>  -422,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>  -436,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-cvs/nnpfs/linux/nnpfs_inodeops.c arla-cvs-new/nnpfs/linux/nnpfs_inodeops.c
--- arla-cvs/nnpfs/linux/nnpfs_inodeops.c	2008-03-08 22:40:10.000000000 +0100
+++ arla-cvs-new/nnpfs/linux/nnpfs_inodeops.c	2010-06-04 14:50:28.358342120 +0200
 <at>  <at>  -138,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>  -244,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>  -314,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>  -429,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>  -515,7 +529,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>  -555,7 +573,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>  -596,8 +618,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>  -640,7 +667,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>  -907,9 +938,18  <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>  -950,7 +990,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>  -995,7 +1039,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>  -1044,9 +1092,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>  -1087,7 +1143,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>  -1132,7 +1192,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>  -1161,22 +1225,39  <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);
 
 <at>  <at>  -1184,6 +1265,7  <at>  <at>  static int nnpfs_symlink(struct inode *d
 	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>  -1402,7 +1484,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>  -1672,11 +1758,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>  -1685,21 +1775,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>  -1905,6 +2010,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>  -1935,14 +2068,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
 };
 
 /*
diff -uprN arla-cvs/nnpfs/linux/nnpfs_message.c arla-cvs-new/nnpfs/linux/nnpfs_message.c
--- arla-cvs/nnpfs/linux/nnpfs_message.c	2006-12-11 17:40:24.000000000 +0100
+++ arla-cvs-new/nnpfs/linux/nnpfs_message.c	2010-06-03 23:32:08.232611383 +0200
 <at>  <at>  -735,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-cvs/nnpfs/linux/nnpfs_syscalls.c arla-cvs-new/nnpfs/linux/nnpfs_syscalls.c
--- arla-cvs/nnpfs/linux/nnpfs_syscalls.c	2007-01-03 15:26:27.000000000 +0100
+++ arla-cvs-new/nnpfs/linux/nnpfs_syscalls.c	2010-06-04 01:19:22.832609437 +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,8 +248,13  <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;
 
     get_group_info(gi);
 <at>  <at>  -242,9 +273,17  <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;
     
 <at>  <at>  -317,7 +356,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 +571,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 +587,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 +627,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 +680,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 +731,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 +841,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 +888,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 +917,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 +967,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-cvs/nnpfs/linux/nnpfs_syscalls-lossage.c arla-cvs-new/nnpfs/linux/nnpfs_syscalls-lossage.c
--- arla-cvs/nnpfs/linux/nnpfs_syscalls-lossage.c	2006-12-11 17:31:45.000000000 +0100
+++ arla-cvs-new/nnpfs/linux/nnpfs_syscalls-lossage.c	2010-06-03 23:32:08.232611383 +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-cvs/nnpfs/linux/nnpfs_vfsops.c arla-cvs-new/nnpfs/linux/nnpfs_vfsops.c
--- arla-cvs/nnpfs/linux/nnpfs_vfsops.c	2006-12-11 17:43:35.000000000 +0100
+++ arla-cvs-new/nnpfs/linux/nnpfs_vfsops.c	2010-06-03 23:32:08.232611383 +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

Gmane