cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

callback.c (6019B)


      1/*
      2 * Copyright (c) 2002, 2007 Red Hat, Inc. All rights reserved.
      3 *
      4 * This software may be freely redistributed under the terms of the
      5 * GNU General Public License.
      6 *
      7 * You should have received a copy of the GNU General Public License
      8 * along with this program; if not, write to the Free Software
      9 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     10 *
     11 * Authors: David Woodhouse <dwmw2@infradead.org>
     12 *          David Howells <dhowells@redhat.com>
     13 *
     14 */
     15
     16#include <linux/kernel.h>
     17#include <linux/module.h>
     18#include <linux/init.h>
     19#include <linux/circ_buf.h>
     20#include <linux/sched.h>
     21#include "internal.h"
     22
     23/*
     24 * Handle invalidation of an mmap'd file.  We invalidate all the PTEs referring
     25 * to the pages in this file's pagecache, forcing the kernel to go through
     26 * ->fault() or ->page_mkwrite() - at which point we can handle invalidation
     27 * more fully.
     28 */
     29void afs_invalidate_mmap_work(struct work_struct *work)
     30{
     31	struct afs_vnode *vnode = container_of(work, struct afs_vnode, cb_work);
     32
     33	unmap_mapping_pages(vnode->netfs.inode.i_mapping, 0, 0, false);
     34}
     35
     36void afs_server_init_callback_work(struct work_struct *work)
     37{
     38	struct afs_server *server = container_of(work, struct afs_server, initcb_work);
     39	struct afs_vnode *vnode;
     40	struct afs_cell *cell = server->cell;
     41
     42	down_read(&cell->fs_open_mmaps_lock);
     43
     44	list_for_each_entry(vnode, &cell->fs_open_mmaps, cb_mmap_link) {
     45		if (vnode->cb_server == server) {
     46			clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
     47			queue_work(system_unbound_wq, &vnode->cb_work);
     48		}
     49	}
     50
     51	up_read(&cell->fs_open_mmaps_lock);
     52}
     53
     54/*
     55 * Allow the fileserver to request callback state (re-)initialisation.
     56 * Unfortunately, UUIDs are not guaranteed unique.
     57 */
     58void afs_init_callback_state(struct afs_server *server)
     59{
     60	rcu_read_lock();
     61	do {
     62		server->cb_s_break++;
     63		atomic_inc(&server->cell->fs_s_break);
     64		if (!list_empty(&server->cell->fs_open_mmaps))
     65			queue_work(system_unbound_wq, &server->initcb_work);
     66
     67	} while ((server = rcu_dereference(server->uuid_next)));
     68	rcu_read_unlock();
     69}
     70
     71/*
     72 * actually break a callback
     73 */
     74void __afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reason)
     75{
     76	_enter("");
     77
     78	clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
     79	if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
     80		vnode->cb_break++;
     81		vnode->cb_v_break = vnode->volume->cb_v_break;
     82		afs_clear_permits(vnode);
     83
     84		if (vnode->lock_state == AFS_VNODE_LOCK_WAITING_FOR_CB)
     85			afs_lock_may_be_available(vnode);
     86
     87		if (reason != afs_cb_break_for_deleted &&
     88		    vnode->status.type == AFS_FTYPE_FILE &&
     89		    atomic_read(&vnode->cb_nr_mmap))
     90			queue_work(system_unbound_wq, &vnode->cb_work);
     91
     92		trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, true);
     93	} else {
     94		trace_afs_cb_break(&vnode->fid, vnode->cb_break, reason, false);
     95	}
     96}
     97
     98void afs_break_callback(struct afs_vnode *vnode, enum afs_cb_break_reason reason)
     99{
    100	write_seqlock(&vnode->cb_lock);
    101	__afs_break_callback(vnode, reason);
    102	write_sequnlock(&vnode->cb_lock);
    103}
    104
    105/*
    106 * Look up a volume by volume ID under RCU conditions.
    107 */
    108static struct afs_volume *afs_lookup_volume_rcu(struct afs_cell *cell,
    109						afs_volid_t vid)
    110{
    111	struct afs_volume *volume = NULL;
    112	struct rb_node *p;
    113	int seq = 0;
    114
    115	do {
    116		/* Unfortunately, rbtree walking doesn't give reliable results
    117		 * under just the RCU read lock, so we have to check for
    118		 * changes.
    119		 */
    120		read_seqbegin_or_lock(&cell->volume_lock, &seq);
    121
    122		p = rcu_dereference_raw(cell->volumes.rb_node);
    123		while (p) {
    124			volume = rb_entry(p, struct afs_volume, cell_node);
    125
    126			if (volume->vid < vid)
    127				p = rcu_dereference_raw(p->rb_left);
    128			else if (volume->vid > vid)
    129				p = rcu_dereference_raw(p->rb_right);
    130			else
    131				break;
    132			volume = NULL;
    133		}
    134
    135	} while (need_seqretry(&cell->volume_lock, seq));
    136
    137	done_seqretry(&cell->volume_lock, seq);
    138	return volume;
    139}
    140
    141/*
    142 * allow the fileserver to explicitly break one callback
    143 * - happens when
    144 *   - the backing file is changed
    145 *   - a lock is released
    146 */
    147static void afs_break_one_callback(struct afs_volume *volume,
    148				   struct afs_fid *fid)
    149{
    150	struct super_block *sb;
    151	struct afs_vnode *vnode;
    152	struct inode *inode;
    153
    154	if (fid->vnode == 0 && fid->unique == 0) {
    155		/* The callback break applies to an entire volume. */
    156		write_lock(&volume->cb_v_break_lock);
    157		volume->cb_v_break++;
    158		trace_afs_cb_break(fid, volume->cb_v_break,
    159				   afs_cb_break_for_volume_callback, false);
    160		write_unlock(&volume->cb_v_break_lock);
    161		return;
    162	}
    163
    164	/* See if we can find a matching inode - even an I_NEW inode needs to
    165	 * be marked as it can have its callback broken before we finish
    166	 * setting up the local inode.
    167	 */
    168	sb = rcu_dereference(volume->sb);
    169	if (!sb)
    170		return;
    171
    172	inode = find_inode_rcu(sb, fid->vnode, afs_ilookup5_test_by_fid, fid);
    173	if (inode) {
    174		vnode = AFS_FS_I(inode);
    175		afs_break_callback(vnode, afs_cb_break_for_callback);
    176	} else {
    177		trace_afs_cb_miss(fid, afs_cb_break_for_callback);
    178	}
    179}
    180
    181static void afs_break_some_callbacks(struct afs_server *server,
    182				     struct afs_callback_break *cbb,
    183				     size_t *_count)
    184{
    185	struct afs_callback_break *residue = cbb;
    186	struct afs_volume *volume;
    187	afs_volid_t vid = cbb->fid.vid;
    188	size_t i;
    189
    190	volume = afs_lookup_volume_rcu(server->cell, vid);
    191
    192	/* TODO: Find all matching volumes if we couldn't match the server and
    193	 * break them anyway.
    194	 */
    195
    196	for (i = *_count; i > 0; cbb++, i--) {
    197		if (cbb->fid.vid == vid) {
    198			_debug("- Fid { vl=%08llx n=%llu u=%u }",
    199			       cbb->fid.vid,
    200			       cbb->fid.vnode,
    201			       cbb->fid.unique);
    202			--*_count;
    203			if (volume)
    204				afs_break_one_callback(volume, &cbb->fid);
    205		} else {
    206			*residue++ = *cbb;
    207		}
    208	}
    209}
    210
    211/*
    212 * allow the fileserver to break callback promises
    213 */
    214void afs_break_callbacks(struct afs_server *server, size_t count,
    215			 struct afs_callback_break *callbacks)
    216{
    217	_enter("%p,%zu,", server, count);
    218
    219	ASSERT(server != NULL);
    220
    221	rcu_read_lock();
    222
    223	while (count > 0)
    224		afs_break_some_callbacks(server, callbacks, &count);
    225
    226	rcu_read_unlock();
    227	return;
    228}