litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Thomas Gleixner <tglx@linutronix.de>	2010-02-22 08:42:04 -0500
committer	H. Peter Anvin <hpa@zytor.com>	2010-02-25 22:26:23 -0500
commit	d5d0e88c1e5b069aadb050ff6ec95df312de876a (patch)
tree	3ad3e5964cc7db89e7fbdb480be611e1193222ca /tools/perf/util/trace-event-scripting.c
parent	4fb6088a5cb3a77123fea1279bf2d5b16cf27648 (diff)

x86, olpc: Use pci subarch init for OLPC

Replace the #ifdef'ed OLPC-specific init functions by a conditional x86_init function. If the function returns 0 we leave pci_arch_init, otherwise we continue. Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Cc: Jesse Barnes <jbarnes@virtuousgeek.org> Cc: Andres Salomon <dilinger@collabora.co.uk> LKML-Reference: <43F901BD926A4E43B106BF17856F0755A318CE89@orsmsx508.amr.corp.intel.com> Signed-off-by: Jacob Pan <jacob.jun.pan@intel.com> Signed-off-by: H. Peter Anvin <hpa@zytor.com>

Diffstat (limited to 'tools/perf/util/trace-event-scripting.c')

0 files changed, 0 insertions, 0 deletions

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175

388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443

/* General filesystem caching interface * * 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. * * NOTE!!! See: * * Documentation/filesystems/caching/netfs-api.txt * * for a description of the network filesystem interface declared here. */ #ifndef _LINUX_FSCACHE_H #define _LINUX_FSCACHE_H #include <linux/fs.h> #include <linux/list.h> #include <linux/pagemap.h> #include <linux/pagevec.h> #if defined(CONFIG_FSCACHE) || defined(CONFIG_FSCACHE_MODULE) #define fscache_available() (1) #define fscache_cookie_valid(cookie) (cookie) #else #define fscache_available() (0) #define fscache_cookie_valid(cookie) (0) #endif /* * overload PG_private_2 to give us PG_fscache - this is used to indicate that * a page is currently backed by a local disk cache */ #define PageFsCache(page) PagePrivate2((page)) #define SetPageFsCache(page) SetPagePrivate2((page)) #define ClearPageFsCache(page) ClearPagePrivate2((page)) #define TestSetPageFsCache(page) TestSetPagePrivate2((page)) #define TestClearPageFsCache(page) TestClearPagePrivate2((page)) /* pattern used to fill dead space in an index entry */ #define FSCACHE_INDEX_DEADFILL_PATTERN 0x79 struct pagevec; struct fscache_cache_tag; struct fscache_cookie; struct fscache_netfs; typedef void (*fscache_rw_complete_t)(struct page *page, void *context, int error); /* result of index entry consultation */ enum fscache_checkaux { FSCACHE_CHECKAUX_OKAY, /* entry okay as is */ FSCACHE_CHECKAUX_NEEDS_UPDATE, /* entry requires update */ FSCACHE_CHECKAUX_OBSOLETE, /* entry requires deletion */ }; /* * fscache cookie definition */ struct fscache_cookie_def { /* name of cookie type */ char name[16]; /* cookie type */ uint8_t type; #define FSCACHE_COOKIE_TYPE_INDEX 0 #define FSCACHE_COOKIE_TYPE_DATAFILE 1 /* select the cache into which to insert an entry in this index * - optional * - should return a cache identifier or NULL to cause the cache to be * inherited from the parent if possible or the first cache picked * for a non-index file if not */ struct fscache_cache_tag *(*select_cache)( const void *parent_netfs_data, const void *cookie_netfs_data); /* get an index key * - should store the key data in the buffer * - should return the amount of data stored * - not permitted to return an error * - the netfs data from the cookie being used as the source is * presented */ uint16_t (*get_key)(const void *cookie_netfs_data, void *buffer, uint16_t bufmax); /* get certain file attributes from the netfs data * - this function can be absent for an index * - not permitted to return an error * - the netfs data from the cookie being used as the source is * presented */ void (*get_attr)(const void *cookie_netfs_data, uint64_t *size); /* get the auxilliary data from netfs data * - this function can be absent if the index carries no state data * - should store the auxilliary data in the buffer * - should return the amount of amount stored * - not permitted to return an error * - the netfs data from the cookie being used as the source is * presented */ uint16_t (*get_aux)(const void *cookie_netfs_data, void *buffer, uint16_t bufmax); /* consult the netfs about the state of an object * - this function can be absent if the index carries no state data * - the netfs data from the cookie being used as the target is * presented, as is the auxilliary data */ enum fscache_checkaux (*check_aux)(void *cookie_netfs_data, const void *data, uint16_t datalen); /* get an extra reference on a read context * - this function can be absent if the completion function doesn't * require a context */ void (*get_context)(void *cookie_netfs_data, void *context); /* release an extra reference on a read context * - this function can be absent if the completion function doesn't * require a context */ void (*put_context)(void *cookie_netfs_data, void *context); /* indicate pages that now have cache metadata retained * - this function should mark the specified pages as now being cached * - the pages will have been marked with PG_fscache before this is * called, so this is optional */ void (*mark_pages_cached)(void *cookie_netfs_data, struct address_space *mapping, struct pagevec *cached_pvec); /* indicate the cookie is no longer cached * - 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 */ void (*now_uncached)(void *cookie_netfs_data); }; /* * fscache cached network filesystem type * - name, version and ops must be filled in before registration * - all other fields will be set during registration */ struct fscache_netfs { uint32_t version; /* indexing version */ const char *name; /* filesystem name */ struct fscache_cookie *primary_index; struct list_head link; /* internal link */ }; /* * slow-path functions for when there is actually caching available, and the * netfs does actually have a valid token * - these are not to be called directly * - these are undefined symbols when FS-Cache is not configured and the * optimiser takes care of not using them */ extern int __fscache_register_netfs(struct fscache_netfs *); extern void __fscache_unregister_netfs(struct fscache_netfs *); extern struct fscache_cache_tag *__fscache_lookup_cache_tag(const char *); extern void __fscache_release_cache_tag(struct fscache_cache_tag *); extern struct fscache_cookie *__fscache_acquire_cookie( struct fscache_cookie *, const struct fscache_cookie_def *, void *); extern void __fscache_relinquish_cookie(struct fscache_cookie *, int); extern void __fscache_update_cookie(struct fscache_cookie *); extern int __fscache_attr_changed(struct fscache_cookie *); extern int __fscache_read_or_alloc_page(struct fscache_cookie *, struct page *, fscache_rw_complete_t, void *, gfp_t); extern int __fscache_read_or_alloc_pages(struct fscache_cookie *, struct address_space *, struct list_head *, unsigned *, fscache_rw_complete_t, void *, gfp_t); extern int __fscache_alloc_page(struct fscache_cookie *, struct page *, gfp_t); extern int __fscache_write_page(struct fscache_cookie *, struct page *, gfp_t); extern void __fscache_uncache_page(struct fscache_cookie *, struct page *); extern bool __fscache_check_page_write(struct fscache_cookie *, struct page *); extern void __fscache_wait_on_page_write(struct fscache_cookie *, struct page *); extern bool __fscache_maybe_release_page(struct fscache_cookie *, struct page *, gfp_t); /** * fscache_register_netfs - Register a filesystem as desiring caching services * @netfs: The description of the filesystem * * Register a filesystem as desiring caching services if they're available. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline int fscache_register_netfs(struct fscache_netfs *netfs) { if (fscache_available()) return __fscache_register_netfs(netfs); else return 0; } /** * fscache_unregister_netfs - Indicate that a filesystem no longer desires * caching services * @netfs: The description of the filesystem * * Indicate that a filesystem no longer desires caching services for the * moment. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline void fscache_unregister_netfs(struct fscache_netfs *netfs) { if (fscache_available()) __fscache_unregister_netfs(netfs); } /** * fscache_lookup_cache_tag - Look up a cache tag * @name: The name of the tag to search for * * Acquire a specific cache referral tag that can be used to select a specific * cache in which to cache an index. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline struct fscache_cache_tag *fscache_lookup_cache_tag(const char *name) { if (fscache_available()) return __fscache_lookup_cache_tag(name); else return NULL; } /** * fscache_release_cache_tag - Release a cache tag * @tag: The tag to release * * Release a reference to a cache referral tag previously looked up. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline void fscache_release_cache_tag(struct fscache_cache_tag *tag) { if (fscache_available()) __fscache_release_cache_tag(tag); } /** * fscache_acquire_cookie - Acquire a cookie to represent a cache object * @parent: The cookie that's to be the parent of this one * @def: A description of the cache object, including callback operations * @netfs_data: An arbitrary piece of data to be kept in the cookie to * represent the cache object to the netfs * * This function is used to inform FS-Cache about part of an index hierarchy * that can be used to locate files. This is done by requesting a cookie for * each index in the path to the file. * * See Documentation/filesystems/caching/netfs-api.txt for a complete * description. */ static inline struct fscache_cookie *fscache_acquire_cookie( struct fscache_cookie *parent, const struct fscache_cookie_def *def, void *netfs_data) {


context:
space:
mode: