xref: /openbmc/linux/fs/afs/volume.c (revision 6a87e0f0ce1ae8d70566935215430e718ea776ff)
1  // SPDX-License-Identifier: GPL-2.0-or-later
2  /* AFS volume management
3   *
4   * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
5   * Written by David Howells (dhowells@redhat.com)
6   */
7  
8  #include <linux/kernel.h>
9  #include <linux/slab.h>
10  #include "internal.h"
11  
12  static unsigned __read_mostly afs_volume_record_life = 60 * 60;
13  
14  /*
15   * Insert a volume into a cell.  If there's an existing volume record, that is
16   * returned instead with a ref held.
17   */
18  static struct afs_volume *afs_insert_volume_into_cell(struct afs_cell *cell,
19  						      struct afs_volume *volume)
20  {
21  	struct afs_volume *p;
22  	struct rb_node *parent = NULL, **pp;
23  
24  	write_seqlock(&cell->volume_lock);
25  
26  	pp = &cell->volumes.rb_node;
27  	while (*pp) {
28  		parent = *pp;
29  		p = rb_entry(parent, struct afs_volume, cell_node);
30  		if (p->vid < volume->vid) {
31  			pp = &(*pp)->rb_left;
32  		} else if (p->vid > volume->vid) {
33  			pp = &(*pp)->rb_right;
34  		} else {
35  			volume = afs_get_volume(p, afs_volume_trace_get_cell_insert);
36  			goto found;
37  		}
38  	}
39  
40  	rb_link_node_rcu(&volume->cell_node, parent, pp);
41  	rb_insert_color(&volume->cell_node, &cell->volumes);
42  	hlist_add_head_rcu(&volume->proc_link, &cell->proc_volumes);
43  
44  found:
45  	write_sequnlock(&cell->volume_lock);
46  	return volume;
47  
48  }
49  
50  static void afs_remove_volume_from_cell(struct afs_volume *volume)
51  {
52  	struct afs_cell *cell = volume->cell;
53  
54  	if (!hlist_unhashed(&volume->proc_link)) {
55  		trace_afs_volume(volume->vid, refcount_read(&cell->ref),
56  				 afs_volume_trace_remove);
57  		write_seqlock(&cell->volume_lock);
58  		hlist_del_rcu(&volume->proc_link);
59  		rb_erase(&volume->cell_node, &cell->volumes);
60  		write_sequnlock(&cell->volume_lock);
61  	}
62  }
63  
64  /*
65   * Allocate a volume record and load it up from a vldb record.
66   */
67  static struct afs_volume *afs_alloc_volume(struct afs_fs_context *params,
68  					   struct afs_vldb_entry *vldb,
69  					   unsigned long type_mask)
70  {
71  	struct afs_server_list *slist;
72  	struct afs_volume *volume;
73  	int ret = -ENOMEM;
74  
75  	volume = kzalloc(sizeof(struct afs_volume), GFP_KERNEL);
76  	if (!volume)
77  		goto error_0;
78  
79  	volume->vid		= vldb->vid[params->type];
80  	volume->update_at	= ktime_get_real_seconds() + afs_volume_record_life;
81  	volume->cell		= afs_get_cell(params->cell, afs_cell_trace_get_vol);
82  	volume->type		= params->type;
83  	volume->type_force	= params->force;
84  	volume->name_len	= vldb->name_len;
85  
86  	refcount_set(&volume->ref, 1);
87  	INIT_HLIST_NODE(&volume->proc_link);
88  	rwlock_init(&volume->servers_lock);
89  	rwlock_init(&volume->cb_v_break_lock);
90  	memcpy(volume->name, vldb->name, vldb->name_len + 1);
91  
92  	slist = afs_alloc_server_list(params->cell, params->key, vldb, type_mask);
93  	if (IS_ERR(slist)) {
94  		ret = PTR_ERR(slist);
95  		goto error_1;
96  	}
97  
98  	refcount_set(&slist->usage, 1);
99  	rcu_assign_pointer(volume->servers, slist);
100  	trace_afs_volume(volume->vid, 1, afs_volume_trace_alloc);
101  	return volume;
102  
103  error_1:
104  	afs_put_cell(volume->cell, afs_cell_trace_put_vol);
105  	kfree(volume);
106  error_0:
107  	return ERR_PTR(ret);
108  }
109  
110  /*
111   * Look up or allocate a volume record.
112   */
113  static struct afs_volume *afs_lookup_volume(struct afs_fs_context *params,
114  					    struct afs_vldb_entry *vldb,
115  					    unsigned long type_mask)
116  {
117  	struct afs_volume *candidate, *volume;
118  
119  	candidate = afs_alloc_volume(params, vldb, type_mask);
120  	if (IS_ERR(candidate))
121  		return candidate;
122  
123  	volume = afs_insert_volume_into_cell(params->cell, candidate);
124  	if (volume != candidate)
125  		afs_put_volume(params->net, candidate, afs_volume_trace_put_cell_dup);
126  	return volume;
127  }
128  
129  /*
130   * Look up a VLDB record for a volume.
131   */
132  static struct afs_vldb_entry *afs_vl_lookup_vldb(struct afs_cell *cell,
133  						 struct key *key,
134  						 const char *volname,
135  						 size_t volnamesz)
136  {
137  	struct afs_vldb_entry *vldb = ERR_PTR(-EDESTADDRREQ);
138  	struct afs_vl_cursor vc;
139  	int ret;
140  
141  	if (!afs_begin_vlserver_operation(&vc, cell, key))
142  		return ERR_PTR(-ERESTARTSYS);
143  
144  	while (afs_select_vlserver(&vc)) {
145  		vldb = afs_vl_get_entry_by_name_u(&vc, volname, volnamesz);
146  	}
147  
148  	ret = afs_end_vlserver_operation(&vc);
149  	return ret < 0 ? ERR_PTR(ret) : vldb;
150  }
151  
152  /*
153   * Look up a volume in the VL server and create a candidate volume record for
154   * it.
155   *
156   * The volume name can be one of the following:
157   *	"%[cell:]volume[.]"		R/W volume
158   *	"#[cell:]volume[.]"		R/O or R/W volume (rwparent=0),
159   *					 or R/W (rwparent=1) volume
160   *	"%[cell:]volume.readonly"	R/O volume
161   *	"#[cell:]volume.readonly"	R/O volume
162   *	"%[cell:]volume.backup"		Backup volume
163   *	"#[cell:]volume.backup"		Backup volume
164   *
165   * The cell name is optional, and defaults to the current cell.
166   *
167   * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin
168   * Guide
169   * - Rule 1: Explicit type suffix forces access of that type or nothing
170   *           (no suffix, then use Rule 2 & 3)
171   * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W
172   *           if not available
173   * - Rule 3: If parent volume is R/W, then only mount R/W volume unless
174   *           explicitly told otherwise
175   */
176  struct afs_volume *afs_create_volume(struct afs_fs_context *params)
177  {
178  	struct afs_vldb_entry *vldb;
179  	struct afs_volume *volume;
180  	unsigned long type_mask = 1UL << params->type;
181  
182  	vldb = afs_vl_lookup_vldb(params->cell, params->key,
183  				  params->volname, params->volnamesz);
184  	if (IS_ERR(vldb))
185  		return ERR_CAST(vldb);
186  
187  	if (test_bit(AFS_VLDB_QUERY_ERROR, &vldb->flags)) {
188  		volume = ERR_PTR(vldb->error);
189  		goto error;
190  	}
191  
192  	/* Make the final decision on the type we want */
193  	volume = ERR_PTR(-ENOMEDIUM);
194  	if (params->force) {
195  		if (!(vldb->flags & type_mask))
196  			goto error;
197  	} else if (test_bit(AFS_VLDB_HAS_RO, &vldb->flags)) {
198  		params->type = AFSVL_ROVOL;
199  	} else if (test_bit(AFS_VLDB_HAS_RW, &vldb->flags)) {
200  		params->type = AFSVL_RWVOL;
201  	} else {
202  		goto error;
203  	}
204  
205  	type_mask = 1UL << params->type;
206  	volume = afs_lookup_volume(params, vldb, type_mask);
207  
208  error:
209  	kfree(vldb);
210  	return volume;
211  }
212  
213  /*
214   * Destroy a volume record
215   */
216  static void afs_destroy_volume(struct afs_net *net, struct afs_volume *volume)
217  {
218  	_enter("%p", volume);
219  
220  #ifdef CONFIG_AFS_FSCACHE
221  	ASSERTCMP(volume->cache, ==, NULL);
222  #endif
223  
224  	afs_remove_volume_from_cell(volume);
225  	afs_put_serverlist(net, rcu_access_pointer(volume->servers));
226  	afs_put_cell(volume->cell, afs_cell_trace_put_vol);
227  	trace_afs_volume(volume->vid, refcount_read(&volume->ref),
228  			 afs_volume_trace_free);
229  	kfree_rcu(volume, rcu);
230  
231  	_leave(" [destroyed]");
232  }
233  
234  /*
235   * Get a reference on a volume record.
236   */
237  struct afs_volume *afs_get_volume(struct afs_volume *volume,
238  				  enum afs_volume_trace reason)
239  {
240  	if (volume) {
241  		int r;
242  
243  		__refcount_inc(&volume->ref, &r);
244  		trace_afs_volume(volume->vid, r + 1, reason);
245  	}
246  	return volume;
247  }
248  
249  
250  /*
251   * Drop a reference on a volume record.
252   */
253  void afs_put_volume(struct afs_net *net, struct afs_volume *volume,
254  		    enum afs_volume_trace reason)
255  {
256  	if (volume) {
257  		afs_volid_t vid = volume->vid;
258  		bool zero;
259  		int r;
260  
261  		zero = __refcount_dec_and_test(&volume->ref, &r);
262  		trace_afs_volume(vid, r - 1, reason);
263  		if (zero)
264  			afs_destroy_volume(net, volume);
265  	}
266  }
267  
268  /*
269   * Activate a volume.
270   */
271  int afs_activate_volume(struct afs_volume *volume)
272  {
273  #ifdef CONFIG_AFS_FSCACHE
274  	struct fscache_volume *vcookie;
275  	char *name;
276  
277  	name = kasprintf(GFP_KERNEL, "afs,%s,%llx",
278  			 volume->cell->name, volume->vid);
279  	if (!name)
280  		return -ENOMEM;
281  
282  	vcookie = fscache_acquire_volume(name, NULL, NULL, 0);
283  	if (IS_ERR(vcookie)) {
284  		if (vcookie != ERR_PTR(-EBUSY)) {
285  			kfree(name);
286  			return PTR_ERR(vcookie);
287  		}
288  		pr_err("AFS: Cache volume key already in use (%s)\n", name);
289  		vcookie = NULL;
290  	}
291  	volume->cache = vcookie;
292  	kfree(name);
293  #endif
294  	return 0;
295  }
296  
297  /*
298   * Deactivate a volume.
299   */
300  void afs_deactivate_volume(struct afs_volume *volume)
301  {
302  	_enter("%s", volume->name);
303  
304  #ifdef CONFIG_AFS_FSCACHE
305  	fscache_relinquish_volume(volume->cache, NULL,
306  				  test_bit(AFS_VOLUME_DELETED, &volume->flags));
307  	volume->cache = NULL;
308  #endif
309  
310  	_leave("");
311  }
312  
313  /*
314   * Query the VL service to update the volume status.
315   */
316  static int afs_update_volume_status(struct afs_volume *volume, struct key *key)
317  {
318  	struct afs_server_list *new, *old, *discard;
319  	struct afs_vldb_entry *vldb;
320  	char idbuf[16];
321  	int ret, idsz;
322  
323  	_enter("");
324  
325  	/* We look up an ID by passing it as a decimal string in the
326  	 * operation's name parameter.
327  	 */
328  	idsz = sprintf(idbuf, "%llu", volume->vid);
329  
330  	vldb = afs_vl_lookup_vldb(volume->cell, key, idbuf, idsz);
331  	if (IS_ERR(vldb)) {
332  		ret = PTR_ERR(vldb);
333  		goto error;
334  	}
335  
336  	/* See if the volume got renamed. */
337  	if (vldb->name_len != volume->name_len ||
338  	    memcmp(vldb->name, volume->name, vldb->name_len) != 0) {
339  		/* TODO: Use RCU'd string. */
340  		memcpy(volume->name, vldb->name, AFS_MAXVOLNAME);
341  		volume->name_len = vldb->name_len;
342  	}
343  
344  	/* See if the volume's server list got updated. */
345  	new = afs_alloc_server_list(volume->cell, key,
346  				    vldb, (1 << volume->type));
347  	if (IS_ERR(new)) {
348  		ret = PTR_ERR(new);
349  		goto error_vldb;
350  	}
351  
352  	write_lock(&volume->servers_lock);
353  
354  	discard = new;
355  	old = rcu_dereference_protected(volume->servers,
356  					lockdep_is_held(&volume->servers_lock));
357  	if (afs_annotate_server_list(new, old)) {
358  		new->seq = volume->servers_seq + 1;
359  		rcu_assign_pointer(volume->servers, new);
360  		smp_wmb();
361  		volume->servers_seq++;
362  		discard = old;
363  	}
364  
365  	volume->update_at = ktime_get_real_seconds() + afs_volume_record_life;
366  	write_unlock(&volume->servers_lock);
367  	ret = 0;
368  
369  	afs_put_serverlist(volume->cell->net, discard);
370  error_vldb:
371  	kfree(vldb);
372  error:
373  	_leave(" = %d", ret);
374  	return ret;
375  }
376  
377  /*
378   * Make sure the volume record is up to date.
379   */
380  int afs_check_volume_status(struct afs_volume *volume, struct afs_operation *op)
381  {
382  	int ret, retries = 0;
383  
384  	_enter("");
385  
386  retry:
387  	if (test_bit(AFS_VOLUME_WAIT, &volume->flags))
388  		goto wait;
389  	if (volume->update_at <= ktime_get_real_seconds() ||
390  	    test_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags))
391  		goto update;
392  	_leave(" = 0");
393  	return 0;
394  
395  update:
396  	if (!test_and_set_bit_lock(AFS_VOLUME_UPDATING, &volume->flags)) {
397  		clear_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);
398  		ret = afs_update_volume_status(volume, op->key);
399  		if (ret < 0)
400  			set_bit(AFS_VOLUME_NEEDS_UPDATE, &volume->flags);
401  		clear_bit_unlock(AFS_VOLUME_WAIT, &volume->flags);
402  		clear_bit_unlock(AFS_VOLUME_UPDATING, &volume->flags);
403  		wake_up_bit(&volume->flags, AFS_VOLUME_WAIT);
404  		_leave(" = %d", ret);
405  		return ret;
406  	}
407  
408  wait:
409  	if (!test_bit(AFS_VOLUME_WAIT, &volume->flags)) {
410  		_leave(" = 0 [no wait]");
411  		return 0;
412  	}
413  
414  	ret = wait_on_bit(&volume->flags, AFS_VOLUME_WAIT,
415  			  (op->flags & AFS_OPERATION_UNINTR) ?
416  			  TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE);
417  	if (ret == -ERESTARTSYS) {
418  		_leave(" = %d", ret);
419  		return ret;
420  	}
421  
422  	retries++;
423  	if (retries == 4) {
424  		_leave(" = -ESTALE");
425  		return -ESTALE;
426  	}
427  	goto retry;
428  }
429