/* Filesystem index definition * * Copyright (C) 2004-2007 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. */ #define FSCACHE_DEBUG_LEVEL CACHE #include #include "internal.h" static uint16_t fscache_fsdef_netfs_get_key(const void *cookie_netfs_data, void *buffer, uint16_t bufmax); static uint16_t fscache_fsdef_netfs_get_aux(const void *cookie_netfs_data, void *buffer, uint16_t bufmax); static enum fscache_checkaux fscache_fsdef_netfs_check_aux(void *cookie_netfs_data, const void *data, uint16_t datalen); /* * The root index is owned by FS-Cache itself. * * When a netfs requests caching facilities, FS-Cache will, if one doesn't * already exist, create an entry in the root index with the key being the name * of the netfs ("AFS" for example), and the auxiliary data holding the index * structure version supplied by the netfs: * * FSDEF * | * +-----------+ * | | * NFS AFS * [v=1] [v=1] * * If an entry with the appropriate name does already exist, the version is * compared. If the version is different, the entire subtree from that entry * will be discarded and a new entry created. * * The new entry will be an index, and a cookie referring to it will be passed * to the netfs. This is then the root handle by which the netfs accesses the * cache. It can create whatever objects it likes in that index, including * further indices. */ static struct fscache_cookie_def fscache_fsdef_index_def = { .name = ".FS-Cache", .type = FSCACHE_COOKIE_TYPE_INDEX, }; struct fscache_cookie fscache_fsdef_index = { .usage = ATOMIC_INIT(1), .n_active = ATOMIC_INIT(1), .lock = __SPIN_LOCK_UNLOCKED(fscache_fsdef_index.lock), .backing_objects = HLIST_HEAD_INIT, .def = &fscache_fsdef_index_def, .flags = 1 << FSCACHE_COOKIE_ENABLED, }; EXPORT_SYMBOL(fscache_fsdef_index); /* * Definition of an entry in the root index. Each entry is an index, keyed to * a specific netfs and only applicable to a particular version of the index * structure used by that netfs. */ struct fscache_cookie_def fscache_fsdef_netfs_def = { .name = "FSDEF.netfs", .type = FSCACHE_COOKIE_TYPE_INDEX, .get_key = fscache_fsdef_netfs_get_key, .get_aux = fscache_fsdef_netfs_get_aux, .check_aux = fscache_fsdef_netfs_check_aux, }; /* * get the key data for an FSDEF index record - this is the name of the netfs * for which this entry is created */ static uint16_t fscache_fsdef_netfs_get_key(const void *cookie_netfs_data, void *buffer, uint16_t bufmax) { const struct fscache_netfs *netfs = cookie_netfs_data; unsigned klen; _enter("{%s.%u},", netfs->name, netfs->version); klen = strlen(netfs->name); if (klen > bufmax) return 0; memcpy(buffer, netfs->name, klen); return klen; } /* * get the auxiliary data for an FSDEF index record - this is the index * structure version number of the netfs for which this version is created */ static uint16_t fscache_fsdef_netfs_get_aux(const void *cookie_netfs_data, void *buffer, uint16_t bufmax) { const struct fscache_netfs *netfs = cookie_netfs_data; unsigned dlen; _enter("{%s.%u},", netfs->name, netfs->version); dlen = sizeof(uint32_t); if (dlen > bufmax) return 0; memcpy(buffer, &netfs->version, dlen); return dlen; } /* * check that the index structure version number stored in the auxiliary data * matches the one the netfs gave us */ static enum fscache_checkaux fscache_fsdef_netfs_check_aux( void *cookie_netfs_data, const void *data, uint16_t datalen) { struct fscache_netfs *netfs = cookie_netfs_data; uint32_t version; _enter("{%s},,%hu", netfs->name, datalen); if (datalen != sizeof(version)) { _leave(" = OBSOLETE [dl=%d v=%zu]", datalen, sizeof(version)); return FSCACHE_CHECKAUX_OBSOLETE; } memcpy(&version, data, sizeof(version)); if (version != netfs->version) { _leave(" = OBSOLETE [ver=%x net=%x]", version, netfs->version); return FSCACHE_CHECKAUX_OBSOLETE; } _leave(" = OKAY"); return FSCACHE_CHECKAUX_OKAY; } bust@primarydata.com>2017-01-24 15:29:24 -0500 commitc929ea0b910355e1876c64431f3d5802f95b3d75 (patch) tree94339f18c2be5b9308b9f44ac8b450fe58bcc645 /sound parenta430607b2ef7c3be090f88c71cfcb1b3988aa7c0 (diff)
SUNRPC: cleanup ida information when removing sunrpc module
After removing sunrpc module, I get many kmemleak information as, unreferenced object 0xffff88003316b1e0 (size 544): comm "gssproxy", pid 2148, jiffies 4294794465 (age 4200.081s) hex dump (first 32 bytes): 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ backtrace: [<ffffffffb0cfb58a>] kmemleak_alloc+0x4a/0xa0 [<ffffffffb03507fe>] kmem_cache_alloc+0x15e/0x1f0 [<ffffffffb0639baa>] ida_pre_get+0xaa/0x150 [<ffffffffb0639cfd>] ida_simple_get+0xad/0x180 [<ffffffffc06054fb>] nlmsvc_lookup_host+0x4ab/0x7f0 [lockd] [<ffffffffc0605e1d>] lockd+0x4d/0x270 [lockd] [<ffffffffc06061e5>] param_set_timeout+0x55/0x100 [lockd] [<ffffffffc06cba24>] svc_defer+0x114/0x3f0 [sunrpc] [<ffffffffc06cbbe7>] svc_defer+0x2d7/0x3f0 [sunrpc] [<ffffffffc06c71da>] rpc_show_info+0x8a/0x110 [sunrpc] [<ffffffffb044a33f>] proc_reg_write+0x7f/0xc0 [<ffffffffb038e41f>] __vfs_write+0xdf/0x3c0 [<ffffffffb0390f1f>] vfs_write+0xef/0x240 [<ffffffffb0392fbd>] SyS_write+0xad/0x130 [<ffffffffb0d06c37>] entry_SYSCALL_64_fastpath+0x1a/0xa9 [<ffffffffffffffff>] 0xffffffffffffffff I found, the ida information (dynamic memory) isn't cleanup. Signed-off-by: Kinglong Mee <kinglongmee@gmail.com> Fixes: 2f048db4680a ("SUNRPC: Add an identifier for struct rpc_clnt") Cc: stable@vger.kernel.org # v3.12+ Signed-off-by: Trond Myklebust <trond.myklebust@primarydata.com>
Diffstat (limited to 'sound')