2010-07-05 16:42:15 +04:00
/*
* fs / cifs / fscache . c - CIFS filesystem cache interface
*
* Copyright ( c ) 2010 Novell , Inc .
2010-11-24 15:19:06 +03:00
* Author ( s ) : Suresh Jayaraman < sjayaraman @ suse . de >
2010-07-05 16:42:15 +04:00
*
* This library is free software ; you can redistribute it and / or modify
* it under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation ; either version 2.1 of the License , or
* ( at your option ) any later version .
*
* This library is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See
* the GNU Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library ; if not , write to the Free Software
* Foundation , Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
*/
# include "fscache.h"
# include "cifsglob.h"
# include "cifs_debug.h"
2010-07-05 16:42:45 +04:00
# include "cifs_fs_sb.h"
2010-07-05 16:42:15 +04:00
void cifs_fscache_get_client_cookie ( struct TCP_Server_Info * server )
{
server - > fscache =
fscache_acquire_cookie ( cifs_fscache_netfs . primary_index ,
& cifs_fscache_server_index_def , server ) ;
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (0x%p/0x%p) " , __func__ , server ,
server - > fscache ) ;
2010-07-05 16:42:15 +04:00
}
void cifs_fscache_release_client_cookie ( struct TCP_Server_Info * server )
{
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (0x%p/0x%p) " , __func__ , server ,
server - > fscache ) ;
2010-07-05 16:42:15 +04:00
fscache_relinquish_cookie ( server - > fscache , 0 ) ;
server - > fscache = NULL ;
}
2011-05-27 08:34:02 +04:00
void cifs_fscache_get_super_cookie ( struct cifs_tcon * tcon )
2010-07-05 16:42:27 +04:00
{
struct TCP_Server_Info * server = tcon - > ses - > server ;
tcon - > fscache =
fscache_acquire_cookie ( server - > fscache ,
& cifs_fscache_super_index_def , tcon ) ;
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (0x%p/0x%p) " , __func__ , server - > fscache ,
tcon - > fscache ) ;
2010-07-05 16:42:27 +04:00
}
2011-05-27 08:34:02 +04:00
void cifs_fscache_release_super_cookie ( struct cifs_tcon * tcon )
2010-07-05 16:42:27 +04:00
{
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (0x%p) " , __func__ , tcon - > fscache ) ;
2010-07-05 16:42:27 +04:00
fscache_relinquish_cookie ( tcon - > fscache , 0 ) ;
tcon - > fscache = NULL ;
}
2010-07-05 16:42:45 +04:00
static void cifs_fscache_enable_inode_cookie ( struct inode * inode )
{
struct cifsInodeInfo * cifsi = CIFS_I ( inode ) ;
struct cifs_sb_info * cifs_sb = CIFS_SB ( inode - > i_sb ) ;
2011-05-27 08:34:02 +04:00
struct cifs_tcon * tcon = cifs_sb_master_tcon ( cifs_sb ) ;
2010-07-05 16:42:45 +04:00
if ( cifsi - > fscache )
return ;
2010-11-24 15:19:06 +03:00
if ( cifs_sb - > mnt_cifs_flags & CIFS_MOUNT_FSCACHE ) {
cifsi - > fscache = fscache_acquire_cookie ( tcon - > fscache ,
2010-09-21 03:01:35 +04:00
& cifs_fscache_inode_object_def , cifsi ) ;
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: got FH cookie (0x%p/0x%p) " , __func__ ,
tcon - > fscache , cifsi - > fscache ) ;
2010-11-24 15:19:06 +03:00
}
2010-07-05 16:42:45 +04:00
}
void cifs_fscache_release_inode_cookie ( struct inode * inode )
{
struct cifsInodeInfo * cifsi = CIFS_I ( inode ) ;
if ( cifsi - > fscache ) {
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (0x%p) " , __func__ , cifsi - > fscache ) ;
2010-07-05 16:42:45 +04:00
fscache_relinquish_cookie ( cifsi - > fscache , 0 ) ;
cifsi - > fscache = NULL ;
}
}
static void cifs_fscache_disable_inode_cookie ( struct inode * inode )
{
struct cifsInodeInfo * cifsi = CIFS_I ( inode ) ;
if ( cifsi - > fscache ) {
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (0x%p) " , __func__ , cifsi - > fscache ) ;
2011-07-07 15:19:48 +04:00
fscache_uncache_all_inode_pages ( cifsi - > fscache , inode ) ;
2010-07-05 16:42:45 +04:00
fscache_relinquish_cookie ( cifsi - > fscache , 1 ) ;
cifsi - > fscache = NULL ;
}
}
void cifs_fscache_set_inode_cookie ( struct inode * inode , struct file * filp )
{
if ( ( filp - > f_flags & O_ACCMODE ) ! = O_RDONLY )
cifs_fscache_disable_inode_cookie ( inode ) ;
2010-11-24 15:19:06 +03:00
else
2010-07-05 16:42:45 +04:00
cifs_fscache_enable_inode_cookie ( inode ) ;
}
void cifs_fscache_reset_inode_cookie ( struct inode * inode )
{
struct cifsInodeInfo * cifsi = CIFS_I ( inode ) ;
struct cifs_sb_info * cifs_sb = CIFS_SB ( inode - > i_sb ) ;
struct fscache_cookie * old = cifsi - > fscache ;
if ( cifsi - > fscache ) {
/* retire the current fscache cache and get a new one */
fscache_relinquish_cookie ( cifsi - > fscache , 1 ) ;
2010-09-21 03:01:33 +04:00
cifsi - > fscache = fscache_acquire_cookie (
2010-09-21 03:01:35 +04:00
cifs_sb_master_tcon ( cifs_sb ) - > fscache ,
2010-07-05 16:42:45 +04:00
& cifs_fscache_inode_object_def ,
cifsi ) ;
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: new cookie 0x%p oldcookie 0x%p " ,
__func__ , cifsi - > fscache , old ) ;
2010-07-05 16:42:45 +04:00
}
}
2010-07-05 16:43:00 +04:00
int cifs_fscache_release_page ( struct page * page , gfp_t gfp )
{
if ( PageFsCache ( page ) ) {
struct inode * inode = page - > mapping - > host ;
struct cifsInodeInfo * cifsi = CIFS_I ( inode ) ;
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (0x%p/0x%p) " , __func__ , page ,
cifsi - > fscache ) ;
2010-07-05 16:43:00 +04:00
if ( ! fscache_maybe_release_page ( cifsi - > fscache , page , gfp ) )
return 0 ;
}
return 1 ;
}
2010-07-05 16:43:25 +04:00
static void cifs_readpage_from_fscache_complete ( struct page * page , void * ctx ,
int error )
{
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (0x%p/%d) " , __func__ , page , error ) ;
2010-07-05 16:43:25 +04:00
if ( ! error )
SetPageUptodate ( page ) ;
unlock_page ( page ) ;
}
/*
* Retrieve a page from FS - Cache
*/
int __cifs_readpage_from_fscache ( struct inode * inode , struct page * page )
{
int ret ;
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (fsc:%p, p:%p, i:0x%p " , __func__ ,
2010-07-05 16:43:25 +04:00
CIFS_I ( inode ) - > fscache , page , inode ) ;
ret = fscache_read_or_alloc_page ( CIFS_I ( inode ) - > fscache , page ,
cifs_readpage_from_fscache_complete ,
NULL ,
GFP_KERNEL ) ;
switch ( ret ) {
case 0 : /* page found in fscache, read submitted */
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: submitted " , __func__ ) ;
2010-07-05 16:43:25 +04:00
return ret ;
case - ENOBUFS : /* page won't be cached */
case - ENODATA : /* page not in cache */
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: %d " , __func__ , ret ) ;
2010-07-05 16:43:25 +04:00
return 1 ;
default :
cERROR ( 1 , " unknown error ret = %d " , ret ) ;
}
return ret ;
}
/*
* Retrieve a set of pages from FS - Cache
*/
int __cifs_readpages_from_fscache ( struct inode * inode ,
struct address_space * mapping ,
struct list_head * pages ,
unsigned * nr_pages )
{
int ret ;
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (0x%p/%u/0x%p) " , __func__ ,
2010-07-05 16:43:25 +04:00
CIFS_I ( inode ) - > fscache , * nr_pages , inode ) ;
ret = fscache_read_or_alloc_pages ( CIFS_I ( inode ) - > fscache , mapping ,
pages , nr_pages ,
cifs_readpage_from_fscache_complete ,
NULL ,
mapping_gfp_mask ( mapping ) ) ;
switch ( ret ) {
case 0 : /* read submitted to the cache for all pages */
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: submitted " , __func__ ) ;
2010-07-05 16:43:25 +04:00
return ret ;
case - ENOBUFS : /* some pages are not cached and can't be */
case - ENODATA : /* some pages are not cached */
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: no page " , __func__ ) ;
2010-07-05 16:43:25 +04:00
return 1 ;
default :
cFYI ( 1 , " unknown error ret = %d " , ret ) ;
}
return ret ;
}
2010-07-05 16:43:11 +04:00
void __cifs_readpage_to_fscache ( struct inode * inode , struct page * page )
{
int ret ;
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (fsc: %p, p: %p, i: %p) " , __func__ ,
2010-07-05 16:43:11 +04:00
CIFS_I ( inode ) - > fscache , page , inode ) ;
ret = fscache_write_page ( CIFS_I ( inode ) - > fscache , page , GFP_KERNEL ) ;
if ( ret ! = 0 )
fscache_uncache_page ( CIFS_I ( inode ) - > fscache , page ) ;
}
2010-07-05 16:43:00 +04:00
void __cifs_fscache_invalidate_page ( struct page * page , struct inode * inode )
{
struct cifsInodeInfo * cifsi = CIFS_I ( inode ) ;
struct fscache_cookie * cookie = cifsi - > fscache ;
2011-06-14 19:51:18 +04:00
cFYI ( 1 , " %s: (0x%p/0x%p) " , __func__ , page , cookie ) ;
2010-07-05 16:43:00 +04:00
fscache_wait_on_page_write ( cookie , page ) ;
fscache_uncache_page ( cookie , page ) ;
}