/* AFS caching stuff
   *

   * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.

   * Written by David Howells (dhowells@redhat.com)
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License
   * as published by the Free Software Foundation; either version
   * 2 of the License, or (at your option) any later version.
   */

  #include <linux/sched.h>
  #include "internal.h"
  
  static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data,
  				       void *buffer, uint16_t buflen);
  static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data,
  				       void *buffer, uint16_t buflen);
  static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data,
  						      const void *buffer,
  						      uint16_t buflen);
  
  static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data,
  					    void *buffer, uint16_t buflen);
  static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data,
  					    void *buffer, uint16_t buflen);
  static enum fscache_checkaux afs_vlocation_cache_check_aux(
  	void *cookie_netfs_data, const void *buffer, uint16_t buflen);
  
  static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data,
  					 void *buffer, uint16_t buflen);
  
  static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
  					void *buffer, uint16_t buflen);
  static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
  				     uint64_t *size);
  static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
  					void *buffer, uint16_t buflen);
  static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
  						       const void *buffer,
  						       uint16_t buflen);
  static void afs_vnode_cache_now_uncached(void *cookie_netfs_data);
  
  struct fscache_netfs afs_cache_netfs = {
  	.name			= "afs",
  	.version		= 0,
  };
  
  struct fscache_cookie_def afs_cell_cache_index_def = {
  	.name		= "AFS.cell",
  	.type		= FSCACHE_COOKIE_TYPE_INDEX,
  	.get_key	= afs_cell_cache_get_key,
  	.get_aux	= afs_cell_cache_get_aux,
  	.check_aux	= afs_cell_cache_check_aux,
  };
  
  struct fscache_cookie_def afs_vlocation_cache_index_def = {
  	.name			= "AFS.vldb",
  	.type			= FSCACHE_COOKIE_TYPE_INDEX,
  	.get_key		= afs_vlocation_cache_get_key,
  	.get_aux		= afs_vlocation_cache_get_aux,
  	.check_aux		= afs_vlocation_cache_check_aux,
  };
  
  struct fscache_cookie_def afs_volume_cache_index_def = {
  	.name		= "AFS.volume",
  	.type		= FSCACHE_COOKIE_TYPE_INDEX,
  	.get_key	= afs_volume_cache_get_key,
  };
  
  struct fscache_cookie_def afs_vnode_cache_index_def = {
  	.name			= "AFS.vnode",
  	.type			= FSCACHE_COOKIE_TYPE_DATAFILE,
  	.get_key		= afs_vnode_cache_get_key,
  	.get_attr		= afs_vnode_cache_get_attr,
  	.get_aux		= afs_vnode_cache_get_aux,
  	.check_aux		= afs_vnode_cache_check_aux,
  	.now_uncached		= afs_vnode_cache_now_uncached,

  };

  
  /*

   * set the key for the index entry

   */

  static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data,
  				       void *buffer, uint16_t bufmax)

  {

  	const struct afs_cell *cell = cookie_netfs_data;
  	uint16_t klen;

  	_enter("%p,%p,%u", cell, buffer, bufmax);

  	klen = strlen(cell->name);
  	if (klen > bufmax)
  		return 0;

  	memcpy(buffer, cell->name, klen);
  	return klen;

  }

  
  /*

   * provide new auxiliary cache data

   */

  static uint16_t afs_cell_cache_get_aux(const void *cookie_netfs_data,
  				       void *buffer, uint16_t bufmax)

  {

  	const struct afs_cell *cell = cookie_netfs_data;
  	uint16_t dlen;

  	_enter("%p,%p,%u", cell, buffer, bufmax);

  	dlen = cell->vl_naddrs * sizeof(cell->vl_addrs[0]);
  	dlen = min(dlen, bufmax);
  	dlen &= ~(sizeof(cell->vl_addrs[0]) - 1);

  	memcpy(buffer, cell->vl_addrs, dlen);
  	return dlen;
  }

  /*

   * check that the auxiliary data indicates that the entry is still valid

   */
  static enum fscache_checkaux afs_cell_cache_check_aux(void *cookie_netfs_data,
  						      const void *buffer,
  						      uint16_t buflen)
  {
  	_leave(" = OKAY");
  	return FSCACHE_CHECKAUX_OKAY;

  }

  /*****************************************************************************/

  /*

   * set the key for the index entry

   */

  static uint16_t afs_vlocation_cache_get_key(const void *cookie_netfs_data,
  					    void *buffer, uint16_t bufmax)

  {

  	const struct afs_vlocation *vlocation = cookie_netfs_data;
  	uint16_t klen;
  
  	_enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax);
  
  	klen = strnlen(vlocation->vldb.name, sizeof(vlocation->vldb.name));
  	if (klen > bufmax)
  		return 0;

  	memcpy(buffer, vlocation->vldb.name, klen);

  	_leave(" = %u", klen);
  	return klen;
  }
  
  /*

   * provide new auxiliary cache data

   */
  static uint16_t afs_vlocation_cache_get_aux(const void *cookie_netfs_data,
  					    void *buffer, uint16_t bufmax)
  {
  	const struct afs_vlocation *vlocation = cookie_netfs_data;
  	uint16_t dlen;
  
  	_enter("{%s},%p,%u", vlocation->vldb.name, buffer, bufmax);
  
  	dlen = sizeof(struct afs_cache_vlocation);
  	dlen -= offsetof(struct afs_cache_vlocation, nservers);
  	if (dlen > bufmax)
  		return 0;
  
  	memcpy(buffer, (uint8_t *)&vlocation->vldb.nservers, dlen);
  
  	_leave(" = %u", dlen);
  	return dlen;
  }
  
  /*

   * check that the auxiliary data indicates that the entry is still valid

   */
  static
  enum fscache_checkaux afs_vlocation_cache_check_aux(void *cookie_netfs_data,
  						    const void *buffer,
  						    uint16_t buflen)
  {
  	const struct afs_cache_vlocation *cvldb;
  	struct afs_vlocation *vlocation = cookie_netfs_data;
  	uint16_t dlen;
  
  	_enter("{%s},%p,%u", vlocation->vldb.name, buffer, buflen);
  
  	/* check the size of the data is what we're expecting */
  	dlen = sizeof(struct afs_cache_vlocation);
  	dlen -= offsetof(struct afs_cache_vlocation, nservers);
  	if (dlen != buflen)
  		return FSCACHE_CHECKAUX_OBSOLETE;
  
  	cvldb = container_of(buffer, struct afs_cache_vlocation, nservers);
  
  	/* if what's on disk is more valid than what's in memory, then use the
  	 * VL record from the cache */
  	if (!vlocation->valid || vlocation->vldb.rtime == cvldb->rtime) {
  		memcpy((uint8_t *)&vlocation->vldb.nservers, buffer, dlen);
  		vlocation->valid = 1;
  		_leave(" = SUCCESS [c->m]");
  		return FSCACHE_CHECKAUX_OKAY;
  	}
  
  	/* need to update the cache if the cached info differs */
  	if (memcmp(&vlocation->vldb, buffer, dlen) != 0) {
  		/* delete if the volume IDs for this name differ */
  		if (memcmp(&vlocation->vldb.vid, &cvldb->vid,
  			   sizeof(cvldb->vid)) != 0

  		    ) {

  			_leave(" = OBSOLETE");
  			return FSCACHE_CHECKAUX_OBSOLETE;

  		}

  
  		_leave(" = UPDATE");
  		return FSCACHE_CHECKAUX_NEEDS_UPDATE;

  	}

  	_leave(" = OKAY");
  	return FSCACHE_CHECKAUX_OKAY;

  }

  /*****************************************************************************/

  /*

   * set the key for the volume index entry

   */

  static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data,
  					void *buffer, uint16_t bufmax)

  {

  	const struct afs_volume *volume = cookie_netfs_data;
  	uint16_t klen;
  
  	_enter("{%u},%p,%u", volume->type, buffer, bufmax);
  
  	klen = sizeof(volume->type);
  	if (klen > bufmax)
  		return 0;

  	memcpy(buffer, &volume->type, sizeof(volume->type));
  
  	_leave(" = %u", klen);
  	return klen;

  }

  /*****************************************************************************/

  /*

   * set the key for the index entry

   */

  static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
  					void *buffer, uint16_t bufmax)

  {

  	const struct afs_vnode *vnode = cookie_netfs_data;
  	uint16_t klen;

  	_enter("{%x,%x,%llx},%p,%u",
  	       vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
  	       buffer, bufmax);

  	klen = sizeof(vnode->fid.vnode);
  	if (klen > bufmax)
  		return 0;
  
  	memcpy(buffer, &vnode->fid.vnode, sizeof(vnode->fid.vnode));

  	_leave(" = %u", klen);
  	return klen;

  }

  
  /*

   * provide updated file attributes

   */

  static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
  				     uint64_t *size)

  {

  	const struct afs_vnode *vnode = cookie_netfs_data;

  	_enter("{%x,%x,%llx},",
  	       vnode->fid.vnode, vnode->fid.unique,
  	       vnode->status.data_version);

  	*size = vnode->status.size;

  }

  
  /*

   * provide new auxiliary cache data

   */
  static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
  					void *buffer, uint16_t bufmax)
  {
  	const struct afs_vnode *vnode = cookie_netfs_data;
  	uint16_t dlen;
  
  	_enter("{%x,%x,%Lx},%p,%u",
  	       vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
  	       buffer, bufmax);
  
  	dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version);
  	if (dlen > bufmax)
  		return 0;
  
  	memcpy(buffer, &vnode->fid.unique, sizeof(vnode->fid.unique));
  	buffer += sizeof(vnode->fid.unique);
  	memcpy(buffer, &vnode->status.data_version,
  	       sizeof(vnode->status.data_version));
  
  	_leave(" = %u", dlen);
  	return dlen;
  }
  
  /*

   * check that the auxiliary data indicates that the entry is still valid

   */

  static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
  						       const void *buffer,
  						       uint16_t buflen)

  {

  	struct afs_vnode *vnode = cookie_netfs_data;
  	uint16_t dlen;
  
  	_enter("{%x,%x,%llx},%p,%u",
  	       vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
  	       buffer, buflen);
  
  	/* check the size of the data is what we're expecting */
  	dlen = sizeof(vnode->fid.unique) + sizeof(vnode->status.data_version);
  	if (dlen != buflen) {
  		_leave(" = OBSOLETE [len %hx != %hx]", dlen, buflen);
  		return FSCACHE_CHECKAUX_OBSOLETE;

  	}

  	if (memcmp(buffer,
  		   &vnode->fid.unique,
  		   sizeof(vnode->fid.unique)
  		   ) != 0) {
  		unsigned unique;
  
  		memcpy(&unique, buffer, sizeof(unique));
  
  		_leave(" = OBSOLETE [uniq %x != %x]",
  		       unique, vnode->fid.unique);
  		return FSCACHE_CHECKAUX_OBSOLETE;
  	}
  
  	if (memcmp(buffer + sizeof(vnode->fid.unique),
  		   &vnode->status.data_version,
  		   sizeof(vnode->status.data_version)
  		   ) != 0) {
  		afs_dataversion_t version;
  
  		memcpy(&version, buffer + sizeof(vnode->fid.unique),
  		       sizeof(version));
  
  		_leave(" = OBSOLETE [vers %llx != %llx]",
  		       version, vnode->status.data_version);
  		return FSCACHE_CHECKAUX_OBSOLETE;

  	}
  
  	_leave(" = SUCCESS");

  	return FSCACHE_CHECKAUX_OKAY;

  }

  
  /*

   * indication the cookie is no longer uncached
   * - this function is called when the backing store currently caching a cookie
   *   is removed
   * - the netfs should use this to clean up any markers indicating cached pages
   * - this is mandatory for any object that may have data

   */

  static void afs_vnode_cache_now_uncached(void *cookie_netfs_data)

  {

  	struct afs_vnode *vnode = cookie_netfs_data;
  	struct pagevec pvec;
  	pgoff_t first;
  	int loop, nr_pages;
  
  	_enter("{%x,%x,%Lx}",
  	       vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version);
  
  	pagevec_init(&pvec, 0);
  	first = 0;
  
  	for (;;) {
  		/* grab a bunch of pages to clean */
  		nr_pages = pagevec_lookup(&pvec, vnode->vfs_inode.i_mapping,
  					  first,
  					  PAGEVEC_SIZE - pagevec_count(&pvec));
  		if (!nr_pages)
  			break;

  		for (loop = 0; loop < nr_pages; loop++)
  			ClearPageFsCache(pvec.pages[loop]);
  
  		first = pvec.pages[nr_pages - 1]->index + 1;
  
  		pvec.nr = nr_pages;
  		pagevec_release(&pvec);
  		cond_resched();
  	}

  	_leave("");

  }