smbd/statcache.c

ソースコードを見る。

関数
void	stat_cache_add (const char *full_orig_name, const char *orig_translated_path, BOOL case_sensitive)
	Add an entry into the stat cache.
BOOL	stat_cache_lookup (connection_struct *conn, pstring name, pstring dirpath, char **start, SMB_STRUCT_STAT *pst)
	Look through the stat cache for an entry
void	send_stat_cache_delete_message (const char *name)
void	stat_cache_delete (const char *name)
unsigned int	fast_string_hash (TDB_DATA *key)
BOOL	reset_stat_cache (void)
変数
static TDB_CONTEXT *	tdb_stat_cache

---

関数

void stat_cache_add	(	const char *	full_orig_name,
		const char *	orig_translated_path,
		BOOL	case_sensitive
	)

Add an entry into the stat cache.

引数:

	full_orig_name	The original name as specified by the client
	orig_translated_path	The name on our filesystem.

覚え書き:

Only the first strlen(orig_translated_path) characters are stored into the cache. This means that full_orig_name will be internally truncated.

statcache.c の 43 行で定義されています。

参照先 TDB_DATA::dptr・TDB_DATA::dsize・reset_stat_cache()・strdup_upper()・tdb_map_size()・tdb_stat_cache・tdb_store_bystring().

参照元 unix_convert().

{
        char *translated_path;
        size_t translated_path_length;
        TDB_DATA data_val;
        char *original_path;
        size_t original_path_length;
        size_t sc_size = lp_max_stat_cache_size();

        if (!lp_stat_cache())
                return;

        if (sc_size && (tdb_map_size(tdb_stat_cache) > sc_size*1024)) {
                reset_stat_cache();
        }

        ZERO_STRUCT(data_val);

        /*
         * Don't cache trivial valid directory entries such as . and ..
         */

        if((*full_orig_name == '\0') || (full_orig_name[0] == '.' && 
                                ((full_orig_name[1] == '\0') ||
                                 (full_orig_name[1] == '.' && full_orig_name[2] == '\0'))))
                return;

        /*
         * If we are in case insentive mode, we don't need to
         * store names that need no translation - else, it
         * would be a waste.
         */

        if(case_sensitive && (strcmp(full_orig_name, orig_translated_path) == 0))
                return;

        /*
         * Remove any trailing '/' characters from the
         * translated path.
         */

        translated_path = SMB_STRDUP(orig_translated_path);
        if (!translated_path)
                return;

        translated_path_length = strlen(translated_path);

        if(translated_path[translated_path_length-1] == '/') {
                translated_path[translated_path_length-1] = '\0';
                translated_path_length--;
        }

        if(case_sensitive) {
                original_path = SMB_STRDUP(full_orig_name);
        } else {
                original_path = strdup_upper(full_orig_name);
        }

        if (!original_path) {
                SAFE_FREE(translated_path);
                return;
        }

        original_path_length = strlen(original_path);

        if(original_path[original_path_length-1] == '/') {
                original_path[original_path_length-1] = '\0';
                original_path_length--;
        }

        if (original_path_length != translated_path_length) {
                if (original_path_length < translated_path_length) {
                        DEBUG(0, ("OOPS - tried to store stat cache entry for weird length paths [%s] %lu and [%s] %lu)!\n",
                                  original_path, (unsigned long)original_path_length, translated_path, (unsigned long)translated_path_length));
                        SAFE_FREE(original_path);
                        SAFE_FREE(translated_path);
                        return;
                }

                /* we only want to index by the first part of original_path,
                        up to the length of translated_path */

                original_path[translated_path_length] = '\0';
                original_path_length = translated_path_length;
        }

        /*
         * New entry or replace old entry.
         */
  
        data_val.dsize = translated_path_length + 1;
        data_val.dptr = translated_path;

        if (tdb_store_bystring(tdb_stat_cache, original_path, data_val, TDB_REPLACE) != 0) {
                DEBUG(0,("stat_cache_add: Error storing entry %s -> %s\n", original_path, translated_path));
        } else {
                DEBUG(5,("stat_cache_add: Added entry (%lx:size%x) %s -> %s\n",
                        (unsigned long)data_val.dptr, (unsigned int)data_val.dsize, original_path, translated_path));
        }

        SAFE_FREE(original_path);
        SAFE_FREE(translated_path);
}

BOOL stat_cache_lookup	(	connection_struct *	conn,
		pstring	name,
		pstring	dirpath,
		char **	start,
		SMB_STRUCT_STAT *	pst
	)

Look through the stat cache for an entry

引数:

	conn	A connection struct to do the stat() with.
	name	The path we are attempting to cache, modified by this routine to be correct as far as the cache can tell us
	dirpath	The path as far as the stat cache told us.
	start	A pointer into name, for where to 'start' in fixing the rest of the name up.
	psd	A stat buffer, NOT from the cache, but just a side-effect.

戻り値:

True if we translated (and did a scuccessful stat on) the entire name.

statcache.c の 161 行で定義されています。

参照先 connection_struct::case_sensitive・TDB_DATA::dptr・TDB_DATA::dsize・strdup_upper()・strnrchr_m()・strrchr_m()・tdb_delete_bystring()・tdb_fetch_bystring()・tdb_stat_cache.

参照元 unix_convert().

{
        char *chk_name;
        size_t namelen;
        BOOL sizechanged = False;
        unsigned int num_components = 0;

        if (!lp_stat_cache())
                return False;
 
        namelen = strlen(name);

        *start = name;

        DO_PROFILE_INC(statcache_lookups);

        /*
         * Don't lookup trivial valid directory entries.
         */
        if((*name == '\0') || (name[0] == '.' && 
                                ((name[1] == '\0') ||
                                 (name[1] == '.' && name[1] == '\0'))))
                return False;

        if (conn->case_sensitive) {
                chk_name = SMB_STRDUP(name);
                if (!chk_name) {
                        DEBUG(0, ("stat_cache_lookup: strdup failed!\n"));
                        return False;
                }

        } else {
                chk_name = strdup_upper(name);
                if (!chk_name) {
                        DEBUG(0, ("stat_cache_lookup: strdup_upper failed!\n"));
                        return False;
                }

                /*
                 * In some language encodings the length changes
                 * if we uppercase. We need to treat this differently
                 * below.
                 */
                if (strlen(chk_name) != namelen)
                        sizechanged = True;
        }

        while (1) {
                TDB_DATA data_val;
                char *sp;

                data_val = tdb_fetch_bystring(tdb_stat_cache, chk_name);
                if(data_val.dptr == NULL || data_val.dsize == 0) {
                        DEBUG(10,("stat_cache_lookup: lookup failed for name [%s]\n", chk_name ));
                        /*
                         * Didn't find it - remove last component for next try.
                         */
                        sp = strrchr_m(chk_name, '/');
                        if (sp) {
                                *sp = '\0';
                                /*
                                 * Count the number of times we have done this,
                                 * we'll need it when reconstructing the string.
                                 */
                                if (sizechanged)
                                        num_components++;

                        } else {
                                /*
                                 * We reached the end of the name - no match.
                                 */
                                DO_PROFILE_INC(statcache_misses);
                                SAFE_FREE(chk_name);
                                return False;
                        }
                        if((*chk_name == '\0') || (strcmp(chk_name, ".") == 0)
                                        || (strcmp(chk_name, "..") == 0)) {
                                DO_PROFILE_INC(statcache_misses);
                                SAFE_FREE(chk_name);
                                return False;
                        }
                } else {
                        BOOL retval;
                        char *translated_path = data_val.dptr;
                        size_t translated_path_length = data_val.dsize - 1;

                        DEBUG(10,("stat_cache_lookup: lookup succeeded for name [%s] -> [%s]\n", chk_name, translated_path ));
                        DO_PROFILE_INC(statcache_hits);
                        if(SMB_VFS_STAT(conn,translated_path, pst) != 0) {
                                /* Discard this entry - it doesn't exist in the filesystem.  */
                                tdb_delete_bystring(tdb_stat_cache, chk_name);
                                SAFE_FREE(chk_name);
                                SAFE_FREE(data_val.dptr);
                                return False;
                        }

                        if (!sizechanged) {
                                memcpy(name, translated_path, MIN(sizeof(pstring)-1, translated_path_length));
                        } else if (num_components == 0) {
                                pstrcpy(name, translated_path);
                        } else {
                                sp = strnrchr_m(name, '/', num_components);
                                if (sp) {
                                        pstring last_component;
                                        pstrcpy(last_component, sp);
                                        pstrcpy(name, translated_path);
                                        pstrcat(name, last_component);
                                } else {
                                        pstrcpy(name, translated_path);
                                }
                        }

                        /* set pointer for 'where to start' on fixing the rest of the name */
                        *start = &name[translated_path_length];
                        if(**start == '/')
                                ++*start;

                        pstrcpy(dirpath, translated_path);
                        retval = (namelen == translated_path_length) ? True : False;
                        SAFE_FREE(chk_name);
                        SAFE_FREE(data_val.dptr);
                        return retval;
                }
        }
}

void send_stat_cache_delete_message

(

const char *

name

)

statcache.c の 292 行で定義されています。

参照先 conn_tdb_ctx()・message_send_all().

{
#ifdef DEVELOPER
        message_send_all(conn_tdb_ctx(),
                        MSG_SMB_STAT_CACHE_DELETE,
                        name,
                        strlen(name)+1,
                        True,
                        NULL);
#endif
}

void stat_cache_delete

(

const char *

name

)

statcache.c の 308 行で定義されています。

参照先 strdup_upper()・tdb_delete_bystring()・tdb_stat_cache.

参照元 smb_stat_cache_delete().

{
        char *lname = strdup_upper(name);

        if (!lname) {
                return;
        }
        DEBUG(10,("stat_cache_delete: deleting name [%s] -> %s\n",
                        lname, name ));

        tdb_delete_bystring(tdb_stat_cache, lname);
        SAFE_FREE(lname);
}

unsigned int fast_string_hash

(

TDB_DATA *

key

)

statcache.c の 328 行で定義されています。

参照先 TDB_DATA::dptr.

参照元 mangle_hash_init()・reset_stat_cache().

{
        unsigned int n = 0;
        const char *p;
        for (p = key->dptr; *p != '\0'; p++) {
                n = ((n << 5) + n) ^ (unsigned int)(*p);
        }
        return n;
}

BOOL reset_stat_cache

(

void

)

statcache.c の 342 行で定義されています。

参照先 fast_string_hash()・tdb_close()・tdb_open_ex()・tdb_stat_cache.

参照元 reload_services()・stat_cache_add().

{
        if (!lp_stat_cache())
                return True;

        if (tdb_stat_cache) {
                tdb_close(tdb_stat_cache);
        }

        /* Create the in-memory tdb using our custom hash function. */
        tdb_stat_cache = tdb_open_ex("statcache", 1031, TDB_INTERNAL,
                                    (O_RDWR|O_CREAT), 0644, NULL, fast_string_hash);

        if (!tdb_stat_cache)
                return False;
        return True;
}

---

変数

TDB_CONTEXT* tdb_stat_cache [static]

statcache.c の 29 行で定義されています。

参照元 reset_stat_cache()・stat_cache_add()・stat_cache_delete()・stat_cache_lookup().

---