On Feb 15, 2011, at 2:29 PM, Benny Halevy wrote:
> On 2011-02-15 14:17, Andy Adamson wrote:
>>
>> On Feb 15, 2011, at 11:37 AM, William A. (Andy) Adamson wrote:
>>
>>> On Tue, Feb 15, 2011 at 11:02 AM, Christoph Hellwig <hch@xxxxxxxxxxxxx> wrote:
>>>> FYI that whole device layout cache thingy looks like a complete fucking
>>>> mess to me.
>>>>
>>>> It's nothing but a trivial hash lookup which is only used in the file
>>>> layout driver. But instead of just having a hash allocated in the file
>>>> layout driver on module load, and a trivial opencoded lookup for it it's
>>>> a massively overcomplicated set of routines. Please rip this stuff out
>>>> before doing further work in this area.
>>>>
>>>> The patch below removes the maze of pointless abstractions and just
>>>> keeps a simple hash of deviceids in the filelayout driver.
>>>
>>>
>>> The abstract layer is so that this code is not replicated per layout
>>> driver. Object and block drivers need to do the same task, and indeed
>>> use this code in their prototypes.
>>> That said, we don't have those other layout drivers in kernel, so
>>> moving it all to the file layout driver is fine with me, so long as we
>>> don't have to move it back once we get other drivers.
>
> Why not move it back later on?
> I don't want to replicate any code if it can be factored out and reused.
Yes, we should move it back later on. Christopher's single patch makes this easy to revert.
-->Andy
>
> Benny
>
>>>
>>> Trond?
>>>
>>> -->Andy
>>
>> OK. We all agree. Move the deviceid cache to the filelayout driver until there is a need for a common cache.
>>
>> -->Andy
>>
>>>
>>>>
>>>>
>>>> Index: linux-2.6/fs/nfs/nfs4filelayout.c
>>>> ===================================================================
>>>> --- linux-2.6.orig/fs/nfs/nfs4filelayout.c 2011-02-15 16:10:51.108421283 +0100
>>>> +++ linux-2.6/fs/nfs/nfs4filelayout.c 2011-02-15 16:55:22.087422176 +0100
>>>> @@ -40,32 +40,6 @@ MODULE_LICENSE("GPL");
>>>> MODULE_AUTHOR("Dean Hildebrand <dhildebz@xxxxxxxxx>");
>>>> MODULE_DESCRIPTION("The NFSv4 file layout driver");
>>>>
>>>> -static int
>>>> -filelayout_set_layoutdriver(struct nfs_server *nfss)
>>>> -{
>>>> - int status = pnfs_alloc_init_deviceid_cache(nfss->nfs_client,
>>>> - nfs4_fl_free_deviceid_callback);
>>>> - if (status) {
>>>> - printk(KERN_WARNING "%s: deviceid cache could not be "
>>>> - "initialized\n", __func__);
>>>> - return status;
>>>> - }
>>>> - dprintk("%s: deviceid cache has been initialized successfully\n",
>>>> - __func__);
>>>> - return 0;
>>>> -}
>>>> -
>>>> -/* Clear out the layout by destroying its device list */
>>>> -static int
>>>> -filelayout_clear_layoutdriver(struct nfs_server *nfss)
>>>> -{
>>>> - dprintk("--> %s\n", __func__);
>>>> -
>>>> - if (nfss->nfs_client->cl_devid_cache)
>>>> - pnfs_put_deviceid_cache(nfss->nfs_client);
>>>> - return 0;
>>>> -}
>>>> -
>>>> /*
>>>> * filelayout_check_layout()
>>>> *
>>>> @@ -99,7 +73,7 @@ filelayout_check_layout(struct pnfs_layo
>>>> }
>>>>
>>>> /* find and reference the deviceid */
>>>> - dsaddr = nfs4_fl_find_get_deviceid(nfss->nfs_client, id);
>>>> + dsaddr = nfs4_fl_find_get_deviceid(id);
>>>> if (dsaddr == NULL) {
>>>> dsaddr = get_device_info(lo->plh_inode, id);
>>>> if (dsaddr == NULL)
>>>> @@ -134,7 +108,7 @@ out:
>>>> dprintk("--> %s returns %d\n", __func__, status);
>>>> return status;
>>>> out_put:
>>>> - pnfs_put_deviceid(nfss->nfs_client->cl_devid_cache, &dsaddr->deviceid);
>>>> + nfs4_fl_put_deviceid(dsaddr);
>>>> goto out;
>>>> }
>>>>
>>>> @@ -243,23 +217,19 @@ filelayout_alloc_lseg(struct pnfs_layout
>>>> static void
>>>> filelayout_free_lseg(struct pnfs_layout_segment *lseg)
>>>> {
>>>> - struct nfs_server *nfss = NFS_SERVER(lseg->pls_layout->plh_inode);
>>>> struct nfs4_filelayout_segment *fl = FILELAYOUT_LSEG(lseg);
>>>>
>>>> dprintk("--> %s\n", __func__);
>>>> - pnfs_put_deviceid(nfss->nfs_client->cl_devid_cache,
>>>> - &fl->dsaddr->deviceid);
>>>> + nfs4_fl_put_deviceid(fl->dsaddr);
>>>> _filelayout_free_lseg(fl);
>>>> }
>>>>
>>>> static struct pnfs_layoutdriver_type filelayout_type = {
>>>> - .id = LAYOUT_NFSV4_1_FILES,
>>>> - .name = "LAYOUT_NFSV4_1_FILES",
>>>> - .owner = THIS_MODULE,
>>>> - .set_layoutdriver = filelayout_set_layoutdriver,
>>>> - .clear_layoutdriver = filelayout_clear_layoutdriver,
>>>> - .alloc_lseg = filelayout_alloc_lseg,
>>>> - .free_lseg = filelayout_free_lseg,
>>>> + .id = LAYOUT_NFSV4_1_FILES,
>>>> + .name = "LAYOUT_NFSV4_1_FILES",
>>>> + .owner = THIS_MODULE,
>>>> + .alloc_lseg = filelayout_alloc_lseg,
>>>> + .free_lseg = filelayout_free_lseg,
>>>> };
>>>>
>>>> static int __init nfs4filelayout_init(void)
>>>> Index: linux-2.6/fs/nfs/nfs4filelayout.h
>>>> ===================================================================
>>>> --- linux-2.6.orig/fs/nfs/nfs4filelayout.h 2011-02-15 16:30:25.270920897 +0100
>>>> +++ linux-2.6/fs/nfs/nfs4filelayout.h 2011-02-15 16:47:50.063445740 +0100
>>>> @@ -56,7 +56,9 @@ struct nfs4_pnfs_ds {
>>>> };
>>>>
>>>> struct nfs4_file_layout_dsaddr {
>>>> - struct pnfs_deviceid_node deviceid;
>>>> + struct hlist_node node;
>>>> + struct nfs4_deviceid deviceid;
>>>> + atomic_t ref;
>>>> u32 stripe_count;
>>>> u8 *stripe_indices;
>>>> u32 ds_num;
>>>> @@ -83,11 +85,11 @@ FILELAYOUT_LSEG(struct pnfs_layout_segme
>>>> generic_hdr);
>>>> }
>>>>
>>>> -extern void nfs4_fl_free_deviceid_callback(struct pnfs_deviceid_node *);
>>>> extern void print_ds(struct nfs4_pnfs_ds *ds);
>>>> extern void print_deviceid(struct nfs4_deviceid *dev_id);
>>>> extern struct nfs4_file_layout_dsaddr *
>>>> -nfs4_fl_find_get_deviceid(struct nfs_client *, struct nfs4_deviceid *dev_id);
>>>> +nfs4_fl_find_get_deviceid(struct nfs4_deviceid *dev_id);
>>>> +extern void nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr);
>>>> struct nfs4_file_layout_dsaddr *
>>>> get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id);
>>>>
>>>> Index: linux-2.6/fs/nfs/nfs4filelayoutdev.c
>>>> ===================================================================
>>>> --- linux-2.6.orig/fs/nfs/nfs4filelayoutdev.c 2011-02-15 16:23:03.480487362 +0100
>>>> +++ linux-2.6/fs/nfs/nfs4filelayoutdev.c 2011-02-15 16:55:02.894924739 +0100
>>>> @@ -37,6 +37,30 @@
>>>> #define NFSDBG_FACILITY NFSDBG_PNFS_LD
>>>>
>>>> /*
>>>> + * Device ID RCU cache. A device ID is unique per client ID and layout type.
>>>> + */
>>>> +#define NFS4_FL_DEVICE_ID_HASH_BITS 5
>>>> +#define NFS4_FL_DEVICE_ID_HASH_SIZE (1 << NFS4_FL_DEVICE_ID_HASH_BITS)
>>>> +#define NFS4_FL_DEVICE_ID_HASH_MASK (NFS4_FL_DEVICE_ID_HASH_SIZE - 1)
>>>> +
>>>> +static inline u32
>>>> +nfs4_fl_deviceid_hash(struct nfs4_deviceid *id)
>>>> +{
>>>> + unsigned char *cptr = (unsigned char *)id->data;
>>>> + unsigned int nbytes = NFS4_DEVICEID4_SIZE;
>>>> + u32 x = 0;
>>>> +
>>>> + while (nbytes--) {
>>>> + x *= 37;
>>>> + x += *cptr++;
>>>> + }
>>>> + return x & NFS4_FL_DEVICE_ID_HASH_MASK;
>>>> +}
>>>> +
>>>> +static struct hlist_head filelayout_deviceid_cache[NFS4_FL_DEVICE_ID_HASH_SIZE];
>>>> +static DEFINE_SPINLOCK(filelayout_deviceid_lock);
>>>> +
>>>> +/*
>>>> * Data server cache
>>>> *
>>>> * Data servers can be mapped to different device ids.
>>>> @@ -122,7 +146,7 @@ nfs4_fl_free_deviceid(struct nfs4_file_l
>>>> struct nfs4_pnfs_ds *ds;
>>>> int i;
>>>>
>>>> - print_deviceid(&dsaddr->deviceid.de_id);
>>>> + print_deviceid(&dsaddr->deviceid);
>>>>
>>>> for (i = 0; i < dsaddr->ds_num; i++) {
>>>> ds = dsaddr->ds_list[i];
>>>> @@ -139,15 +163,6 @@ nfs4_fl_free_deviceid(struct nfs4_file_l
>>>> kfree(dsaddr);
>>>> }
>>>>
>>>> -void
>>>> -nfs4_fl_free_deviceid_callback(struct pnfs_deviceid_node *device)
>>>> -{
>>>> - struct nfs4_file_layout_dsaddr *dsaddr =
>>>> - container_of(device, struct nfs4_file_layout_dsaddr, deviceid);
>>>> -
>>>> - nfs4_fl_free_deviceid(dsaddr);
>>>> -}
>>>> -
>>>> static struct nfs4_pnfs_ds *
>>>> nfs4_pnfs_ds_add(struct inode *inode, u32 ip_addr, u32 port)
>>>> {
>>>> @@ -296,7 +311,7 @@ decode_device(struct inode *ino, struct
>>>> dsaddr->stripe_count = cnt;
>>>> dsaddr->ds_num = num;
>>>>
>>>> - memcpy(&dsaddr->deviceid.de_id, &pdev->dev_id, sizeof(pdev->dev_id));
>>>> + memcpy(&dsaddr->deviceid, &pdev->dev_id, sizeof(pdev->dev_id));
>>>>
>>>> /* Go back an read stripe indices */
>>>> p = indicesp;
>>>> @@ -346,28 +361,37 @@ out_err:
>>>> }
>>>>
>>>> /*
>>>> - * Decode the opaque device specified in 'dev'
>>>> - * and add it to the list of available devices.
>>>> - * If the deviceid is already cached, nfs4_add_deviceid will return
>>>> - * a pointer to the cached struct and throw away the new.
>>>> + * Decode the opaque device specified in 'dev' and add it to the cache of
>>>> + * available devices.
>>>> */
>>>> -static struct nfs4_file_layout_dsaddr*
>>>> +static struct nfs4_file_layout_dsaddr *
>>>> decode_and_add_device(struct inode *inode, struct pnfs_device *dev)
>>>> {
>>>> - struct nfs4_file_layout_dsaddr *dsaddr;
>>>> - struct pnfs_deviceid_node *d;
>>>> + struct nfs4_file_layout_dsaddr *d, *new;
>>>> + long hash;
>>>>
>>>> - dsaddr = decode_device(inode, dev);
>>>> - if (!dsaddr) {
>>>> + new = decode_device(inode, dev);
>>>> + if (!new) {
>>>> printk(KERN_WARNING "%s: Could not decode or add device\n",
>>>> __func__);
>>>> return NULL;
>>>> }
>>>>
>>>> - d = pnfs_add_deviceid(NFS_SERVER(inode)->nfs_client->cl_devid_cache,
>>>> - &dsaddr->deviceid);
>>>> + spin_lock(&filelayout_deviceid_lock);
>>>> + d = nfs4_fl_find_get_deviceid(&new->deviceid);
>>>> + if (d) {
>>>> + spin_unlock(&filelayout_deviceid_lock);
>>>> + nfs4_fl_free_deviceid(new);
>>>> + return d;
>>>> + }
>>>> +
>>>> + INIT_HLIST_NODE(&new->node);
>>>> + atomic_set(&new->ref, 1);
>>>> + hash = nfs4_fl_deviceid_hash(&new->deviceid);
>>>> + hlist_add_head_rcu(&new->node, &filelayout_deviceid_cache[hash]);
>>>> + spin_unlock(&filelayout_deviceid_lock);
>>>>
>>>> - return container_of(d, struct nfs4_file_layout_dsaddr, deviceid);
>>>> + return new;
>>>> }
>>>>
>>>> /*
>>>> @@ -442,12 +466,36 @@ out_free:
>>>> return dsaddr;
>>>> }
>>>>
>>>> +void
>>>> +nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr)
>>>> +{
>>>> + if (atomic_dec_and_lock(&dsaddr->ref, &filelayout_deviceid_lock)) {
>>>> + hlist_del_rcu(&dsaddr->node);
>>>> + spin_unlock(&filelayout_deviceid_lock);
>>>> +
>>>> + synchronize_rcu();
>>>> + nfs4_fl_free_deviceid(dsaddr);
>>>> + }
>>>> +}
>>>> +
>>>> struct nfs4_file_layout_dsaddr *
>>>> -nfs4_fl_find_get_deviceid(struct nfs_client *clp, struct nfs4_deviceid *id)
>>>> +nfs4_fl_find_get_deviceid(struct nfs4_deviceid *id)
>>>> {
>>>> - struct pnfs_deviceid_node *d;
>>>> + struct nfs4_file_layout_dsaddr *d;
>>>> + struct hlist_node *n;
>>>> + long hash = nfs4_fl_deviceid_hash(id);
>>>> +
>>>>
>>>> - d = pnfs_find_get_deviceid(clp->cl_devid_cache, id);
>>>> - return (d == NULL) ? NULL :
>>>> - container_of(d, struct nfs4_file_layout_dsaddr, deviceid);
>>>> + rcu_read_lock();
>>>> + hlist_for_each_entry_rcu(d, n, &filelayout_deviceid_cache[hash], node) {
>>>> + if (!memcmp(&d->deviceid, id, sizeof(*id))) {
>>>> + if (!atomic_inc_not_zero(&d->ref))
>>>> + goto fail;
>>>> + rcu_read_unlock();
>>>> + return d;
>>>> + }
>>>> + }
>>>> +fail:
>>>> + rcu_read_unlock();
>>>> + return NULL;
>>>> }
>>>> Index: linux-2.6/fs/nfs/pnfs.c
>>>> ===================================================================
>>>> --- linux-2.6.orig/fs/nfs/pnfs.c 2011-02-15 16:10:33.284421051 +0100
>>>> +++ linux-2.6/fs/nfs/pnfs.c 2011-02-15 16:21:47.115422052 +0100
>>>> @@ -74,10 +74,8 @@ find_pnfs_driver(u32 id)
>>>> void
>>>> unset_pnfs_layoutdriver(struct nfs_server *nfss)
>>>> {
>>>> - if (nfss->pnfs_curr_ld) {
>>>> - nfss->pnfs_curr_ld->clear_layoutdriver(nfss);
>>>> + if (nfss->pnfs_curr_ld)
>>>> module_put(nfss->pnfs_curr_ld->owner);
>>>> - }
>>>> nfss->pnfs_curr_ld = NULL;
>>>> }
>>>>
>>>> @@ -115,13 +113,7 @@ set_pnfs_layoutdriver(struct nfs_server
>>>> goto out_no_driver;
>>>> }
>>>> server->pnfs_curr_ld = ld_type;
>>>> - if (ld_type->set_layoutdriver(server)) {
>>>> - printk(KERN_ERR
>>>> - "%s: Error initializing mount point for layout driver %u.\n",
>>>> - __func__, id);
>>>> - module_put(ld_type->owner);
>>>> - goto out_no_driver;
>>>> - }
>>>> +
>>>> dprintk("%s: pNFS module for %u set\n", __func__, id);
>>>> return;
>>>>
>>>> @@ -828,138 +820,3 @@ out_forget_reply:
>>>> NFS_SERVER(ino)->pnfs_curr_ld->free_lseg(lseg);
>>>> goto out;
>>>> }
>>>> -
>>>> -/*
>>>> - * Device ID cache. Currently supports one layout type per struct nfs_client.
>>>> - * Add layout type to the lookup key to expand to support multiple types.
>>>> - */
>>>> -int
>>>> -pnfs_alloc_init_deviceid_cache(struct nfs_client *clp,
>>>> - void (*free_callback)(struct pnfs_deviceid_node *))
>>>> -{
>>>> - struct pnfs_deviceid_cache *c;
>>>> -
>>>> - c = kzalloc(sizeof(struct pnfs_deviceid_cache), GFP_KERNEL);
>>>> - if (!c)
>>>> - return -ENOMEM;
>>>> - spin_lock(&clp->cl_lock);
>>>> - if (clp->cl_devid_cache != NULL) {
>>>> - atomic_inc(&clp->cl_devid_cache->dc_ref);
>>>> - dprintk("%s [kref [%d]]\n", __func__,
>>>> - atomic_read(&clp->cl_devid_cache->dc_ref));
>>>> - kfree(c);
>>>> - } else {
>>>> - /* kzalloc initializes hlists */
>>>> - spin_lock_init(&c->dc_lock);
>>>> - atomic_set(&c->dc_ref, 1);
>>>> - c->dc_free_callback = free_callback;
>>>> - clp->cl_devid_cache = c;
>>>> - dprintk("%s [new]\n", __func__);
>>>> - }
>>>> - spin_unlock(&clp->cl_lock);
>>>> - return 0;
>>>> -}
>>>> -EXPORT_SYMBOL_GPL(pnfs_alloc_init_deviceid_cache);
>>>> -
>>>> -/*
>>>> - * Called from pnfs_layoutdriver_type->free_lseg
>>>> - * last layout segment reference frees deviceid
>>>> - */
>>>> -void
>>>> -pnfs_put_deviceid(struct pnfs_deviceid_cache *c,
>>>> - struct pnfs_deviceid_node *devid)
>>>> -{
>>>> - struct nfs4_deviceid *id = &devid->de_id;
>>>> - struct pnfs_deviceid_node *d;
>>>> - struct hlist_node *n;
>>>> - long h = nfs4_deviceid_hash(id);
>>>> -
>>>> - dprintk("%s [%d]\n", __func__, atomic_read(&devid->de_ref));
>>>> - if (!atomic_dec_and_lock(&devid->de_ref, &c->dc_lock))
>>>> - return;
>>>> -
>>>> - hlist_for_each_entry_rcu(d, n, &c->dc_deviceids[h], de_node)
>>>> - if (!memcmp(&d->de_id, id, sizeof(*id))) {
>>>> - hlist_del_rcu(&d->de_node);
>>>> - spin_unlock(&c->dc_lock);
>>>> - synchronize_rcu();
>>>> - c->dc_free_callback(devid);
>>>> - return;
>>>> - }
>>>> - spin_unlock(&c->dc_lock);
>>>> - /* Why wasn't it found in the list? */
>>>> - BUG();
>>>> -}
>>>> -EXPORT_SYMBOL_GPL(pnfs_put_deviceid);
>>>> -
>>>> -/* Find and reference a deviceid */
>>>> -struct pnfs_deviceid_node *
>>>> -pnfs_find_get_deviceid(struct pnfs_deviceid_cache *c, struct nfs4_deviceid *id)
>>>> -{
>>>> - struct pnfs_deviceid_node *d;
>>>> - struct hlist_node *n;
>>>> - long hash = nfs4_deviceid_hash(id);
>>>> -
>>>> - dprintk("--> %s hash %ld\n", __func__, hash);
>>>> - rcu_read_lock();
>>>> - hlist_for_each_entry_rcu(d, n, &c->dc_deviceids[hash], de_node) {
>>>> - if (!memcmp(&d->de_id, id, sizeof(*id))) {
>>>> - if (!atomic_inc_not_zero(&d->de_ref)) {
>>>> - goto fail;
>>>> - } else {
>>>> - rcu_read_unlock();
>>>> - return d;
>>>> - }
>>>> - }
>>>> - }
>>>> -fail:
>>>> - rcu_read_unlock();
>>>> - return NULL;
>>>> -}
>>>> -EXPORT_SYMBOL_GPL(pnfs_find_get_deviceid);
>>>> -
>>>> -/*
>>>> - * Add a deviceid to the cache.
>>>> - * GETDEVICEINFOs for same deviceid can race. If deviceid is found, discard new
>>>> - */
>>>> -struct pnfs_deviceid_node *
>>>> -pnfs_add_deviceid(struct pnfs_deviceid_cache *c, struct pnfs_deviceid_node *new)
>>>> -{
>>>> - struct pnfs_deviceid_node *d;
>>>> - long hash = nfs4_deviceid_hash(&new->de_id);
>>>> -
>>>> - dprintk("--> %s hash %ld\n", __func__, hash);
>>>> - spin_lock(&c->dc_lock);
>>>> - d = pnfs_find_get_deviceid(c, &new->de_id);
>>>> - if (d) {
>>>> - spin_unlock(&c->dc_lock);
>>>> - dprintk("%s [discard]\n", __func__);
>>>> - c->dc_free_callback(new);
>>>> - return d;
>>>> - }
>>>> - INIT_HLIST_NODE(&new->de_node);
>>>> - atomic_set(&new->de_ref, 1);
>>>> - hlist_add_head_rcu(&new->de_node, &c->dc_deviceids[hash]);
>>>> - spin_unlock(&c->dc_lock);
>>>> - dprintk("%s [new]\n", __func__);
>>>> - return new;
>>>> -}
>>>> -EXPORT_SYMBOL_GPL(pnfs_add_deviceid);
>>>> -
>>>> -void
>>>> -pnfs_put_deviceid_cache(struct nfs_client *clp)
>>>> -{
>>>> - struct pnfs_deviceid_cache *local = clp->cl_devid_cache;
>>>> -
>>>> - dprintk("--> %s ({%d})\n", __func__, atomic_read(&local->dc_ref));
>>>> - if (atomic_dec_and_lock(&local->dc_ref, &clp->cl_lock)) {
>>>> - int i;
>>>> - /* Verify cache is empty */
>>>> - for (i = 0; i < NFS4_DEVICE_ID_HASH_SIZE; i++)
>>>> - BUG_ON(!hlist_empty(&local->dc_deviceids[i]));
>>>> - clp->cl_devid_cache = NULL;
>>>> - spin_unlock(&clp->cl_lock);
>>>> - kfree(local);
>>>> - }
>>>> -}
>>>> -EXPORT_SYMBOL_GPL(pnfs_put_deviceid_cache);
>>>> Index: linux-2.6/fs/nfs/pnfs.h
>>>> ===================================================================
>>>> --- linux-2.6.orig/fs/nfs/pnfs.h 2011-02-15 16:10:51.088421060 +0100
>>>> +++ linux-2.6/fs/nfs/pnfs.h 2011-02-15 16:21:34.995159583 +0100
>>>> @@ -61,8 +61,6 @@ struct pnfs_layoutdriver_type {
>>>> const u32 id;
>>>> const char *name;
>>>> struct module *owner;
>>>> - int (*set_layoutdriver) (struct nfs_server *);
>>>> - int (*clear_layoutdriver) (struct nfs_server *);
>>>> struct pnfs_layout_segment * (*alloc_lseg) (struct pnfs_layout_hdr *layoutid, struct nfs4_layoutget_res *lgr);
>>>> void (*free_lseg) (struct pnfs_layout_segment *lseg);
>>>> };
>>>> @@ -90,52 +88,6 @@ struct pnfs_device {
>>>> unsigned int pglen;
>>>> };
>>>>
>>>> -/*
>>>> - * Device ID RCU cache. A device ID is unique per client ID and layout type.
>>>> - */
>>>> -#define NFS4_DEVICE_ID_HASH_BITS 5
>>>> -#define NFS4_DEVICE_ID_HASH_SIZE (1 << NFS4_DEVICE_ID_HASH_BITS)
>>>> -#define NFS4_DEVICE_ID_HASH_MASK (NFS4_DEVICE_ID_HASH_SIZE - 1)
>>>> -
>>>> -static inline u32
>>>> -nfs4_deviceid_hash(struct nfs4_deviceid *id)
>>>> -{
>>>> - unsigned char *cptr = (unsigned char *)id->data;
>>>> - unsigned int nbytes = NFS4_DEVICEID4_SIZE;
>>>> - u32 x = 0;
>>>> -
>>>> - while (nbytes--) {
>>>> - x *= 37;
>>>> - x += *cptr++;
>>>> - }
>>>> - return x & NFS4_DEVICE_ID_HASH_MASK;
>>>> -}
>>>> -
>>>> -struct pnfs_deviceid_node {
>>>> - struct hlist_node de_node;
>>>> - struct nfs4_deviceid de_id;
>>>> - atomic_t de_ref;
>>>> -};
>>>> -
>>>> -struct pnfs_deviceid_cache {
>>>> - spinlock_t dc_lock;
>>>> - atomic_t dc_ref;
>>>> - void (*dc_free_callback)(struct pnfs_deviceid_node *);
>>>> - struct hlist_head dc_deviceids[NFS4_DEVICE_ID_HASH_SIZE];
>>>> -};
>>>> -
>>>> -extern int pnfs_alloc_init_deviceid_cache(struct nfs_client *,
>>>> - void (*free_callback)(struct pnfs_deviceid_node *));
>>>> -extern void pnfs_put_deviceid_cache(struct nfs_client *);
>>>> -extern struct pnfs_deviceid_node *pnfs_find_get_deviceid(
>>>> - struct pnfs_deviceid_cache *,
>>>> - struct nfs4_deviceid *);
>>>> -extern struct pnfs_deviceid_node *pnfs_add_deviceid(
>>>> - struct pnfs_deviceid_cache *,
>>>> - struct pnfs_deviceid_node *);
>>>> -extern void pnfs_put_deviceid(struct pnfs_deviceid_cache *c,
>>>> - struct pnfs_deviceid_node *devid);
>>>> -
>>>> extern int pnfs_register_layoutdriver(struct pnfs_layoutdriver_type *);
>>>> extern void pnfs_unregister_layoutdriver(struct pnfs_layoutdriver_type *);
>>>>
>>>> Index: linux-2.6/include/linux/nfs_fs_sb.h
>>>> ===================================================================
>>>> --- linux-2.6.orig/include/linux/nfs_fs_sb.h 2011-02-15 16:16:45.976420895 +0100
>>>> +++ linux-2.6/include/linux/nfs_fs_sb.h 2011-02-15 16:16:50.347380534 +0100
>>>> @@ -79,7 +79,6 @@ struct nfs_client {
>>>> u32 cl_exchange_flags;
>>>> struct nfs4_session *cl_session; /* sharred session */
>>>> struct list_head cl_layouts;
>>>> - struct pnfs_deviceid_cache *cl_devid_cache; /* pNFS deviceid cache */
>>>> #endif /* CONFIG_NFS_V4_1 */
>>>>
>>>> #ifdef CONFIG_NFS_FSCACHE
>>>> --
>>>> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
>>>> the body of a message to majordomo@xxxxxxxxxxxxxxx
>>>> More majordomo info at http://vger.kernel.org/majordomo-info.html
>>>>
>>> --
>>> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
>>> the body of a message to majordomo@xxxxxxxxxxxxxxx
>>> More majordomo info at http://vger.kernel.org/majordomo-info.html
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
>> the body of a message to majordomo@xxxxxxxxxxxxxxx
>> More majordomo info at http://vger.kernel.org/majordomo-info.html
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at http://vger.kernel.org/majordomo-info.html
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
