blob: e817fc740ba019bfb27b1e6d9af5a538f1152d79 [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
David Howellsec268152007-04-26 15:49:28 -07002/* /proc interface for AFS
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 */
7
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/slab.h>
9#include <linux/module.h>
10#include <linux/proc_fs.h>
11#include <linux/seq_file.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040012#include <linux/sched.h>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080013#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include "internal.h"
15
David Howells0a5143f2018-10-20 00:57:57 +010016struct afs_vl_seq_net_private {
17 struct seq_net_private seq; /* Must be first */
18 struct afs_vlserver_list *vllist;
19};
20
David Howellsf044c882017-11-02 15:27:45 +000021static inline struct afs_net *afs_seq2net(struct seq_file *m)
22{
David Howells5b86d4f2018-05-18 11:46:15 +010023 return afs_net(seq_file_net(m));
24}
25
26static inline struct afs_net *afs_seq2net_single(struct seq_file *m)
27{
28 return afs_net(seq_file_single_net(m));
David Howellsf044c882017-11-02 15:27:45 +000029}
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Linus Torvalds1da177e2005-04-16 15:20:36 -070031/*
David Howells5d9de252018-05-18 11:46:15 +010032 * Display the list of cells known to the namespace.
David Howellsf0691682018-05-18 11:46:14 +010033 */
34static int afs_proc_cells_show(struct seq_file *m, void *v)
35{
David Howellsded2f4c2018-10-20 00:57:57 +010036 struct afs_vlserver_list *vllist;
37 struct afs_cell *cell;
David Howellsf0691682018-05-18 11:46:14 +010038
David Howells6b3944e2018-10-11 22:45:49 +010039 if (v == SEQ_START_TOKEN) {
David Howellsf0691682018-05-18 11:46:14 +010040 /* display header on line 1 */
David Howells8a070a92020-04-25 10:26:02 +010041 seq_puts(m, "USE TTL SV ST NAME\n");
David Howellsf0691682018-05-18 11:46:14 +010042 return 0;
43 }
44
David Howellsded2f4c2018-10-20 00:57:57 +010045 cell = list_entry(v, struct afs_cell, proc_link);
46 vllist = rcu_dereference(cell->vl_servers);
47
David Howellsf0691682018-05-18 11:46:14 +010048 /* display one cell per line on subsequent lines */
David Howells8a070a92020-04-25 10:26:02 +010049 seq_printf(m, "%3u %6lld %2u %2u %s\n",
David Howellsded2f4c2018-10-20 00:57:57 +010050 atomic_read(&cell->usage),
51 cell->dns_expiry - ktime_get_real_seconds(),
David Howellsca1cbbd2019-05-07 15:30:34 +010052 vllist->nr_servers,
David Howells8a070a92020-04-25 10:26:02 +010053 cell->state,
David Howellsded2f4c2018-10-20 00:57:57 +010054 cell->name);
David Howellsf0691682018-05-18 11:46:14 +010055 return 0;
56}
57
Linus Torvalds1da177e2005-04-16 15:20:36 -070058static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
David Howellsfe342cf2018-04-09 21:12:31 +010059 __acquires(rcu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070060{
David Howells989782d2017-11-02 15:27:50 +000061 rcu_read_lock();
David Howells6b3944e2018-10-11 22:45:49 +010062 return seq_hlist_start_head_rcu(&afs_seq2net(m)->proc_cells, *_pos);
David Howellsec268152007-04-26 15:49:28 -070063}
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
David Howellsf044c882017-11-02 15:27:45 +000065static void *afs_proc_cells_next(struct seq_file *m, void *v, loff_t *pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
David Howells6b3944e2018-10-11 22:45:49 +010067 return seq_hlist_next_rcu(v, &afs_seq2net(m)->proc_cells, pos);
David Howellsec268152007-04-26 15:49:28 -070068}
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
David Howellsf044c882017-11-02 15:27:45 +000070static void afs_proc_cells_stop(struct seq_file *m, void *v)
David Howellsfe342cf2018-04-09 21:12:31 +010071 __releases(rcu)
Linus Torvalds1da177e2005-04-16 15:20:36 -070072{
David Howells989782d2017-11-02 15:27:50 +000073 rcu_read_unlock();
David Howellsec268152007-04-26 15:49:28 -070074}
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
David Howells5d9de252018-05-18 11:46:15 +010076static const struct seq_operations afs_proc_cells_ops = {
77 .start = afs_proc_cells_start,
78 .next = afs_proc_cells_next,
79 .stop = afs_proc_cells_stop,
80 .show = afs_proc_cells_show,
81};
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 * handle writes to /proc/fs/afs/cells
85 * - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]"
86 */
David Howells5b86d4f2018-05-18 11:46:15 +010087static int afs_proc_cells_write(struct file *file, char *buf, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -070088{
David Howells5b86d4f2018-05-18 11:46:15 +010089 struct seq_file *m = file->private_data;
90 struct afs_net *net = afs_seq2net(m);
91 char *name, *args;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 int ret;
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 /* trim to first NL */
David Howells5b86d4f2018-05-18 11:46:15 +010095 name = memchr(buf, '\n', size);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 if (name)
97 *name = 0;
98
99 /* split into command, name and argslist */
David Howells5b86d4f2018-05-18 11:46:15 +0100100 name = strchr(buf, ' ');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 if (!name)
102 goto inval;
103 do {
104 *name++ = 0;
105 } while(*name == ' ');
106 if (!*name)
107 goto inval;
108
109 args = strchr(name, ' ');
David Howellsecfe9512018-09-07 23:55:17 +0100110 if (args) {
111 do {
112 *args++ = 0;
113 } while(*args == ' ');
114 if (!*args)
115 goto inval;
116 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118 /* determine command to perform */
David Howells5b86d4f2018-05-18 11:46:15 +0100119 _debug("cmd=%s name=%s args=%s", buf, name, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
David Howells5b86d4f2018-05-18 11:46:15 +0100121 if (strcmp(buf, "add") == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 struct afs_cell *cell;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
David Howells989782d2017-11-02 15:27:50 +0000124 cell = afs_lookup_cell(net, name, strlen(name), args, true);
David Howells08e0e7c2007-04-26 15:55:03 -0700125 if (IS_ERR(cell)) {
126 ret = PTR_ERR(cell);
127 goto done;
128 }
129
David Howells17814ae2018-04-09 21:12:31 +0100130 if (test_and_set_bit(AFS_CELL_FL_NO_GC, &cell->flags))
131 afs_put_cell(net, cell);
David Howellsec268152007-04-26 15:49:28 -0700132 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 goto inval;
134 }
135
David Howells5b86d4f2018-05-18 11:46:15 +0100136 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
David Howellsec268152007-04-26 15:49:28 -0700138done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 _leave(" = %d", ret);
140 return ret;
141
David Howellsec268152007-04-26 15:49:28 -0700142inval:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 ret = -EINVAL;
144 printk("kAFS: Invalid Command on /proc/fs/afs/cells file\n");
145 goto done;
David Howellsec268152007-04-26 15:49:28 -0700146}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
David Howells5d9de252018-05-18 11:46:15 +0100148/*
David Howells5b86d4f2018-05-18 11:46:15 +0100149 * Display the name of the current workstation cell.
David Howells5d9de252018-05-18 11:46:15 +0100150 */
David Howells5b86d4f2018-05-18 11:46:15 +0100151static int afs_proc_rootcell_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
David Howells37ab6362018-04-06 14:17:23 +0100153 struct afs_cell *cell;
David Howells5b86d4f2018-05-18 11:46:15 +0100154 struct afs_net *net;
David Howells37ab6362018-04-06 14:17:23 +0100155
David Howells5b86d4f2018-05-18 11:46:15 +0100156 net = afs_seq2net_single(m);
157 if (rcu_access_pointer(net->ws_cell)) {
158 rcu_read_lock();
159 cell = rcu_dereference(net->ws_cell);
160 if (cell)
161 seq_printf(m, "%s\n", cell->name);
162 rcu_read_unlock();
163 }
164 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165}
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167/*
David Howells5d9de252018-05-18 11:46:15 +0100168 * Set the current workstation cell and optionally supply its list of volume
169 * location servers.
170 *
171 * echo "cell.name:192.168.231.14" >/proc/fs/afs/rootcell
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 */
David Howells5b86d4f2018-05-18 11:46:15 +0100173static int afs_proc_rootcell_write(struct file *file, char *buf, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174{
David Howells5b86d4f2018-05-18 11:46:15 +0100175 struct seq_file *m = file->private_data;
176 struct afs_net *net = afs_seq2net_single(m);
177 char *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 int ret;
179
David Howells6f8880d2018-04-09 21:12:31 +0100180 ret = -EINVAL;
David Howells5b86d4f2018-05-18 11:46:15 +0100181 if (buf[0] == '.')
David Howells6f8880d2018-04-09 21:12:31 +0100182 goto out;
David Howells5b86d4f2018-05-18 11:46:15 +0100183 if (memchr(buf, '/', size))
David Howells6f8880d2018-04-09 21:12:31 +0100184 goto out;
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 /* trim to first NL */
David Howells5b86d4f2018-05-18 11:46:15 +0100187 s = memchr(buf, '\n', size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 if (s)
189 *s = 0;
190
191 /* determine command to perform */
David Howells5b86d4f2018-05-18 11:46:15 +0100192 _debug("rootcell=%s", buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
David Howells5b86d4f2018-05-18 11:46:15 +0100194 ret = afs_cell_init(net, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
David Howells6f8880d2018-04-09 21:12:31 +0100196out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 _leave(" = %d", ret);
198 return ret;
David Howellsec268152007-04-26 15:49:28 -0700199}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
David Howellsf0691682018-05-18 11:46:14 +0100201static const char afs_vol_types[3][3] = {
202 [AFSVL_RWVOL] = "RW",
203 [AFSVL_ROVOL] = "RO",
204 [AFSVL_BACKVOL] = "BK",
205};
206
207/*
David Howells5d9de252018-05-18 11:46:15 +0100208 * Display the list of volumes known to a cell.
David Howellsf0691682018-05-18 11:46:14 +0100209 */
210static int afs_proc_cell_volumes_show(struct seq_file *m, void *v)
211{
David Howells20325962020-04-30 01:03:49 +0100212 struct afs_volume *vol = hlist_entry(v, struct afs_volume, proc_link);
David Howellsf0691682018-05-18 11:46:14 +0100213
214 /* Display header on line 1 */
David Howells20325962020-04-30 01:03:49 +0100215 if (v == SEQ_START_TOKEN) {
David Howells50559802019-12-11 08:58:59 +0000216 seq_puts(m, "USE VID TY NAME\n");
David Howellsf0691682018-05-18 11:46:14 +0100217 return 0;
218 }
219
David Howells50559802019-12-11 08:58:59 +0000220 seq_printf(m, "%3d %08llx %s %s\n",
David Howellsf0691682018-05-18 11:46:14 +0100221 atomic_read(&vol->usage), vol->vid,
David Howells50559802019-12-11 08:58:59 +0000222 afs_vol_types[vol->type],
223 vol->name);
David Howellsf0691682018-05-18 11:46:14 +0100224
225 return 0;
226}
227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
David Howellsfe342cf2018-04-09 21:12:31 +0100229 __acquires(cell->proc_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230{
Christoph Hellwig353861c2018-04-13 20:45:09 +0200231 struct afs_cell *cell = PDE_DATA(file_inode(m->file));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
David Howells20325962020-04-30 01:03:49 +0100233 rcu_read_lock();
234 return seq_hlist_start_head_rcu(&cell->proc_volumes, *_pos);
David Howellsec268152007-04-26 15:49:28 -0700235}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
David Howells5b86d4f2018-05-18 11:46:15 +0100237static void *afs_proc_cell_volumes_next(struct seq_file *m, void *v,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 loff_t *_pos)
239{
David Howells5b86d4f2018-05-18 11:46:15 +0100240 struct afs_cell *cell = PDE_DATA(file_inode(m->file));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
David Howells20325962020-04-30 01:03:49 +0100242 return seq_hlist_next_rcu(v, &cell->proc_volumes, _pos);
David Howellsec268152007-04-26 15:49:28 -0700243}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
David Howells5b86d4f2018-05-18 11:46:15 +0100245static void afs_proc_cell_volumes_stop(struct seq_file *m, void *v)
David Howellsfe342cf2018-04-09 21:12:31 +0100246 __releases(cell->proc_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
David Howells20325962020-04-30 01:03:49 +0100248 rcu_read_unlock();
David Howellsec268152007-04-26 15:49:28 -0700249}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
David Howells5d9de252018-05-18 11:46:15 +0100251static const struct seq_operations afs_proc_cell_volumes_ops = {
252 .start = afs_proc_cell_volumes_start,
253 .next = afs_proc_cell_volumes_next,
254 .stop = afs_proc_cell_volumes_stop,
255 .show = afs_proc_cell_volumes_show,
256};
257
David Howells0a5143f2018-10-20 00:57:57 +0100258static const char *const dns_record_sources[NR__dns_record_source + 1] = {
259 [DNS_RECORD_UNAVAILABLE] = "unav",
260 [DNS_RECORD_FROM_CONFIG] = "cfg",
261 [DNS_RECORD_FROM_DNS_A] = "A",
262 [DNS_RECORD_FROM_DNS_AFSDB] = "AFSDB",
263 [DNS_RECORD_FROM_DNS_SRV] = "SRV",
264 [DNS_RECORD_FROM_NSS] = "nss",
265 [NR__dns_record_source] = "[weird]"
266};
267
268static const char *const dns_lookup_statuses[NR__dns_lookup_status + 1] = {
269 [DNS_LOOKUP_NOT_DONE] = "no-lookup",
270 [DNS_LOOKUP_GOOD] = "good",
271 [DNS_LOOKUP_GOOD_WITH_BAD] = "good/bad",
272 [DNS_LOOKUP_BAD] = "bad",
273 [DNS_LOOKUP_GOT_NOT_FOUND] = "not-found",
274 [DNS_LOOKUP_GOT_LOCAL_FAILURE] = "local-failure",
275 [DNS_LOOKUP_GOT_TEMP_FAILURE] = "temp-failure",
276 [DNS_LOOKUP_GOT_NS_FAILURE] = "ns-failure",
277 [NR__dns_lookup_status] = "[weird]"
278};
279
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280/*
David Howells5d9de252018-05-18 11:46:15 +0100281 * Display the list of Volume Location servers we're using for a cell.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 */
David Howellsf0691682018-05-18 11:46:14 +0100283static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284{
David Howells0a5143f2018-10-20 00:57:57 +0100285 const struct afs_vl_seq_net_private *priv = m->private;
286 const struct afs_vlserver_list *vllist = priv->vllist;
287 const struct afs_vlserver_entry *entry;
288 const struct afs_vlserver *vlserver;
289 const struct afs_addr_list *alist;
290 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
David Howells0a5143f2018-10-20 00:57:57 +0100292 if (v == SEQ_START_TOKEN) {
293 seq_printf(m, "# source %s, status %s\n",
David Howellsca1cbbd2019-05-07 15:30:34 +0100294 dns_record_sources[vllist ? vllist->source : 0],
295 dns_lookup_statuses[vllist ? vllist->status : 0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 return 0;
297 }
298
David Howells0a5143f2018-10-20 00:57:57 +0100299 entry = v;
300 vlserver = entry->server;
301 alist = rcu_dereference(vlserver->addresses);
302
303 seq_printf(m, "%s [p=%hu w=%hu s=%s,%s]:\n",
304 vlserver->name, entry->priority, entry->weight,
305 dns_record_sources[alist ? alist->source : entry->source],
306 dns_lookup_statuses[alist ? alist->status : entry->status]);
307 if (alist) {
308 for (i = 0; i < alist->nr_addrs; i++)
309 seq_printf(m, " %c %pISpc\n",
David Howells3bf0fb62018-10-20 00:57:59 +0100310 alist->preferred == i ? '>' : '-',
David Howells0a5143f2018-10-20 00:57:57 +0100311 &alist->addrs[i].transport);
312 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 return 0;
David Howellsec268152007-04-26 15:49:28 -0700314}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316static void *afs_proc_cell_vlservers_start(struct seq_file *m, loff_t *_pos)
David Howellsfe342cf2018-04-09 21:12:31 +0100317 __acquires(rcu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318{
David Howells0a5143f2018-10-20 00:57:57 +0100319 struct afs_vl_seq_net_private *priv = m->private;
320 struct afs_vlserver_list *vllist;
Christoph Hellwig353861c2018-04-13 20:45:09 +0200321 struct afs_cell *cell = PDE_DATA(file_inode(m->file));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 loff_t pos = *_pos;
323
David Howells8b2a4642017-11-02 15:27:50 +0000324 rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
David Howells0a5143f2018-10-20 00:57:57 +0100326 vllist = rcu_dereference(cell->vl_servers);
327 priv->vllist = vllist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
David Howells0a5143f2018-10-20 00:57:57 +0100329 if (pos < 0)
330 *_pos = pos = 0;
331 if (pos == 0)
332 return SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
David Howellsca1cbbd2019-05-07 15:30:34 +0100334 if (pos - 1 >= vllist->nr_servers)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 return NULL;
336
David Howells0a5143f2018-10-20 00:57:57 +0100337 return &vllist->servers[pos - 1];
David Howellsec268152007-04-26 15:49:28 -0700338}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
David Howells5b86d4f2018-05-18 11:46:15 +0100340static void *afs_proc_cell_vlservers_next(struct seq_file *m, void *v,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 loff_t *_pos)
342{
David Howells0a5143f2018-10-20 00:57:57 +0100343 struct afs_vl_seq_net_private *priv = m->private;
344 struct afs_vlserver_list *vllist = priv->vllist;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 loff_t pos;
346
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 pos = *_pos;
David Howells0a5143f2018-10-20 00:57:57 +0100348 pos++;
349 *_pos = pos;
350 if (!vllist || pos - 1 >= vllist->nr_servers)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 return NULL;
352
David Howells0a5143f2018-10-20 00:57:57 +0100353 return &vllist->servers[pos - 1];
David Howellsec268152007-04-26 15:49:28 -0700354}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
David Howells5b86d4f2018-05-18 11:46:15 +0100356static void afs_proc_cell_vlservers_stop(struct seq_file *m, void *v)
David Howellsfe342cf2018-04-09 21:12:31 +0100357 __releases(rcu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
David Howells8b2a4642017-11-02 15:27:50 +0000359 rcu_read_unlock();
David Howellsec268152007-04-26 15:49:28 -0700360}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
David Howells5d9de252018-05-18 11:46:15 +0100362static const struct seq_operations afs_proc_cell_vlservers_ops = {
363 .start = afs_proc_cell_vlservers_start,
364 .next = afs_proc_cell_vlservers_next,
365 .stop = afs_proc_cell_vlservers_stop,
366 .show = afs_proc_cell_vlservers_show,
367};
368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369/*
David Howells5d9de252018-05-18 11:46:15 +0100370 * Display the list of fileservers we're using within a namespace.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 */
David Howellsf0691682018-05-18 11:46:14 +0100372static int afs_proc_servers_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373{
David Howellsf0691682018-05-18 11:46:14 +0100374 struct afs_server *server;
375 struct afs_addr_list *alist;
David Howells0aac4bce2018-06-02 22:20:31 +0100376 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
David Howellsf0691682018-05-18 11:46:14 +0100378 if (v == SEQ_START_TOKEN) {
David Howells6d043a52020-04-20 22:34:12 +0100379 seq_puts(m, "UUID REF ACT\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 return 0;
381 }
382
David Howellsf0691682018-05-18 11:46:14 +0100383 server = list_entry(v, struct afs_server, proc_link);
384 alist = rcu_dereference(server->addresses);
David Howells6d043a52020-04-20 22:34:12 +0100385 seq_printf(m, "%pU %3d %3d\n",
David Howellsf0691682018-05-18 11:46:14 +0100386 &server->uuid,
David Howells977e5f82020-04-17 17:31:26 +0100387 atomic_read(&server->ref),
David Howells6d043a52020-04-20 22:34:12 +0100388 atomic_read(&server->active));
David Howells32275d32020-05-02 13:44:50 +0100389 seq_printf(m, " - info: fl=%lx rtt=%u brk=%x\n",
390 server->flags, server->rtt, server->cb_s_break);
391 seq_printf(m, " - probe: last=%d out=%d\n",
392 (int)(jiffies - server->probed_at) / HZ,
393 atomic_read(&server->probe_outstanding));
394 seq_printf(m, " - ALIST v=%u rsp=%lx f=%lx\n",
395 alist->version, alist->responded, alist->failed);
David Howells6d043a52020-04-20 22:34:12 +0100396 for (i = 0; i < alist->nr_addrs; i++)
397 seq_printf(m, " [%x] %pISpc%s\n",
398 i, &alist->addrs[i].transport,
David Howells3bf0fb62018-10-20 00:57:59 +0100399 alist->preferred == i ? "*" : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 return 0;
David Howellsec268152007-04-26 15:49:28 -0700401}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
David Howellsd2ddc772017-11-02 15:27:50 +0000403static void *afs_proc_servers_start(struct seq_file *m, loff_t *_pos)
David Howellsfe342cf2018-04-09 21:12:31 +0100404 __acquires(rcu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
David Howellsd2ddc772017-11-02 15:27:50 +0000406 rcu_read_lock();
David Howells5d9de252018-05-18 11:46:15 +0100407 return seq_hlist_start_head_rcu(&afs_seq2net(m)->fs_proc, *_pos);
David Howellsec268152007-04-26 15:49:28 -0700408}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
David Howellsd2ddc772017-11-02 15:27:50 +0000410static void *afs_proc_servers_next(struct seq_file *m, void *v, loff_t *_pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411{
David Howells5d9de252018-05-18 11:46:15 +0100412 return seq_hlist_next_rcu(v, &afs_seq2net(m)->fs_proc, _pos);
David Howellsec268152007-04-26 15:49:28 -0700413}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
David Howells5b86d4f2018-05-18 11:46:15 +0100415static void afs_proc_servers_stop(struct seq_file *m, void *v)
David Howellsfe342cf2018-04-09 21:12:31 +0100416 __releases(rcu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417{
David Howellsd2ddc772017-11-02 15:27:50 +0000418 rcu_read_unlock();
David Howellsec268152007-04-26 15:49:28 -0700419}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
David Howells5d9de252018-05-18 11:46:15 +0100421static const struct seq_operations afs_proc_servers_ops = {
422 .start = afs_proc_servers_start,
423 .next = afs_proc_servers_next,
424 .stop = afs_proc_servers_stop,
425 .show = afs_proc_servers_show,
426};
David Howells6f8880d2018-04-09 21:12:31 +0100427
David Howells6f8880d2018-04-09 21:12:31 +0100428/*
David Howells5d9de252018-05-18 11:46:15 +0100429 * Display the list of strings that may be substituted for the @sys pathname
430 * macro.
David Howells6f8880d2018-04-09 21:12:31 +0100431 */
David Howells5d9de252018-05-18 11:46:15 +0100432static int afs_proc_sysname_show(struct seq_file *m, void *v)
David Howells6f8880d2018-04-09 21:12:31 +0100433{
David Howells5d9de252018-05-18 11:46:15 +0100434 struct afs_net *net = afs_seq2net(m);
435 struct afs_sysnames *sysnames = net->sysnames;
436 unsigned int i = (unsigned long)v - 1;
David Howells6f8880d2018-04-09 21:12:31 +0100437
David Howells5d9de252018-05-18 11:46:15 +0100438 if (i < sysnames->nr)
439 seq_printf(m, "%s\n", sysnames->subs[i]);
David Howells6f8880d2018-04-09 21:12:31 +0100440 return 0;
441}
442
David Howells5d9de252018-05-18 11:46:15 +0100443static void *afs_proc_sysname_start(struct seq_file *m, loff_t *pos)
444 __acquires(&net->sysnames_lock)
445{
446 struct afs_net *net = afs_seq2net(m);
David Howells5b86d4f2018-05-18 11:46:15 +0100447 struct afs_sysnames *names;
David Howells5d9de252018-05-18 11:46:15 +0100448
449 read_lock(&net->sysnames_lock);
450
David Howells5b86d4f2018-05-18 11:46:15 +0100451 names = net->sysnames;
David Howells5d9de252018-05-18 11:46:15 +0100452 if (*pos >= names->nr)
453 return NULL;
454 return (void *)(unsigned long)(*pos + 1);
455}
456
457static void *afs_proc_sysname_next(struct seq_file *m, void *v, loff_t *pos)
458{
459 struct afs_net *net = afs_seq2net(m);
460 struct afs_sysnames *names = net->sysnames;
461
462 *pos += 1;
463 if (*pos >= names->nr)
464 return NULL;
465 return (void *)(unsigned long)(*pos + 1);
466}
467
468static void afs_proc_sysname_stop(struct seq_file *m, void *v)
469 __releases(&net->sysnames_lock)
470{
471 struct afs_net *net = afs_seq2net(m);
472
473 read_unlock(&net->sysnames_lock);
474}
475
476static const struct seq_operations afs_proc_sysname_ops = {
477 .start = afs_proc_sysname_start,
478 .next = afs_proc_sysname_next,
479 .stop = afs_proc_sysname_stop,
480 .show = afs_proc_sysname_show,
481};
482
David Howells6f8880d2018-04-09 21:12:31 +0100483/*
David Howells5d9de252018-05-18 11:46:15 +0100484 * Allow the @sys substitution to be configured.
David Howells6f8880d2018-04-09 21:12:31 +0100485 */
David Howells5b86d4f2018-05-18 11:46:15 +0100486static int afs_proc_sysname_write(struct file *file, char *buf, size_t size)
David Howells6f8880d2018-04-09 21:12:31 +0100487{
David Howells5b86d4f2018-05-18 11:46:15 +0100488 struct afs_sysnames *sysnames, *kill;
David Howells6f8880d2018-04-09 21:12:31 +0100489 struct seq_file *m = file->private_data;
David Howells5b86d4f2018-05-18 11:46:15 +0100490 struct afs_net *net = afs_seq2net(m);
491 char *s, *p, *sub;
David Howells6f8880d2018-04-09 21:12:31 +0100492 int ret, len;
493
David Howells5b86d4f2018-05-18 11:46:15 +0100494 sysnames = kzalloc(sizeof(*sysnames), GFP_KERNEL);
David Howells6f8880d2018-04-09 21:12:31 +0100495 if (!sysnames)
David Howells5b86d4f2018-05-18 11:46:15 +0100496 return -ENOMEM;
497 refcount_set(&sysnames->usage, 1);
498 kill = sysnames;
David Howells6f8880d2018-04-09 21:12:31 +0100499
David Howells5b86d4f2018-05-18 11:46:15 +0100500 p = buf;
David Howells6f8880d2018-04-09 21:12:31 +0100501 while ((s = strsep(&p, " \t\n"))) {
502 len = strlen(s);
503 if (len == 0)
504 continue;
505 ret = -ENAMETOOLONG;
506 if (len >= AFSNAMEMAX)
507 goto error;
508
509 if (len >= 4 &&
510 s[len - 4] == '@' &&
511 s[len - 3] == 's' &&
512 s[len - 2] == 'y' &&
513 s[len - 1] == 's')
514 /* Protect against recursion */
515 goto invalid;
516
517 if (s[0] == '.' &&
518 (len < 2 || (len == 2 && s[1] == '.')))
519 goto invalid;
520
521 if (memchr(s, '/', len))
522 goto invalid;
523
524 ret = -EFBIG;
525 if (sysnames->nr >= AFS_NR_SYSNAME)
526 goto out;
527
528 if (strcmp(s, afs_init_sysname) == 0) {
529 sub = (char *)afs_init_sysname;
530 } else {
531 ret = -ENOMEM;
532 sub = kmemdup(s, len + 1, GFP_KERNEL);
533 if (!sub)
534 goto out;
535 }
536
537 sysnames->subs[sysnames->nr] = sub;
538 sysnames->nr++;
539 }
540
David Howells5b86d4f2018-05-18 11:46:15 +0100541 if (sysnames->nr == 0) {
542 sysnames->subs[0] = sysnames->blank;
543 sysnames->nr++;
544 }
545
546 write_lock(&net->sysnames_lock);
547 kill = net->sysnames;
548 net->sysnames = sysnames;
549 write_unlock(&net->sysnames_lock);
550 ret = 0;
David Howells6f8880d2018-04-09 21:12:31 +0100551out:
David Howells5b86d4f2018-05-18 11:46:15 +0100552 afs_put_sysnames(kill);
David Howells6f8880d2018-04-09 21:12:31 +0100553 return ret;
554
555invalid:
556 ret = -EINVAL;
557error:
David Howells6f8880d2018-04-09 21:12:31 +0100558 goto out;
559}
560
David Howells5d9de252018-05-18 11:46:15 +0100561void afs_put_sysnames(struct afs_sysnames *sysnames)
562{
563 int i;
564
565 if (sysnames && refcount_dec_and_test(&sysnames->usage)) {
566 for (i = 0; i < sysnames->nr; i++)
567 if (sysnames->subs[i] != afs_init_sysname &&
568 sysnames->subs[i] != sysnames->blank)
569 kfree(sysnames->subs[i]);
Zhihao Cheng2ca068b2020-06-02 09:30:45 +0800570 kfree(sysnames);
David Howells5d9de252018-05-18 11:46:15 +0100571 }
572}
573
David Howellsd55b4da2018-04-06 14:17:24 +0100574/*
575 * Display general per-net namespace statistics
576 */
577static int afs_proc_stats_show(struct seq_file *m, void *v)
578{
David Howells5b86d4f2018-05-18 11:46:15 +0100579 struct afs_net *net = afs_seq2net_single(m);
David Howellsd55b4da2018-04-06 14:17:24 +0100580
581 seq_puts(m, "kAFS statistics\n");
582
David Howellsf3ddee82018-04-06 14:17:25 +0100583 seq_printf(m, "dir-mgmt: look=%u reval=%u inval=%u relpg=%u\n",
David Howellsd55b4da2018-04-06 14:17:24 +0100584 atomic_read(&net->n_lookup),
585 atomic_read(&net->n_reval),
David Howellsf3ddee82018-04-06 14:17:25 +0100586 atomic_read(&net->n_inval),
587 atomic_read(&net->n_relpg));
David Howellsd55b4da2018-04-06 14:17:24 +0100588
589 seq_printf(m, "dir-data: rdpg=%u\n",
590 atomic_read(&net->n_read_dir));
David Howells63a46812018-04-06 14:17:25 +0100591
592 seq_printf(m, "dir-edit: cr=%u rm=%u\n",
593 atomic_read(&net->n_dir_cr),
594 atomic_read(&net->n_dir_rm));
David Howells76a5cb62018-04-06 14:17:26 +0100595
596 seq_printf(m, "file-rd : n=%u nb=%lu\n",
597 atomic_read(&net->n_fetches),
598 atomic_long_read(&net->n_fetch_bytes));
599 seq_printf(m, "file-wr : n=%u nb=%lu\n",
600 atomic_read(&net->n_stores),
601 atomic_long_read(&net->n_store_bytes));
David Howellsd55b4da2018-04-06 14:17:24 +0100602 return 0;
603}
David Howells10495a02018-05-18 11:46:14 +0100604
605/*
606 * initialise /proc/fs/afs/<cell>/
607 */
David Howells5b86d4f2018-05-18 11:46:15 +0100608int afs_proc_cell_setup(struct afs_cell *cell)
David Howells10495a02018-05-18 11:46:14 +0100609{
610 struct proc_dir_entry *dir;
David Howells5b86d4f2018-05-18 11:46:15 +0100611 struct afs_net *net = cell->net;
David Howells10495a02018-05-18 11:46:14 +0100612
613 _enter("%p{%s},%p", cell, cell->name, net->proc_afs);
614
David Howells5b86d4f2018-05-18 11:46:15 +0100615 dir = proc_net_mkdir(net->net, cell->name, net->proc_afs);
David Howells10495a02018-05-18 11:46:14 +0100616 if (!dir)
617 goto error_dir;
618
David Howells5b86d4f2018-05-18 11:46:15 +0100619 if (!proc_create_net_data("vlservers", 0444, dir,
620 &afs_proc_cell_vlservers_ops,
David Howells0a5143f2018-10-20 00:57:57 +0100621 sizeof(struct afs_vl_seq_net_private),
David Howells5b86d4f2018-05-18 11:46:15 +0100622 cell) ||
623 !proc_create_net_data("volumes", 0444, dir,
624 &afs_proc_cell_volumes_ops,
625 sizeof(struct seq_net_private),
626 cell))
David Howells10495a02018-05-18 11:46:14 +0100627 goto error_tree;
628
629 _leave(" = 0");
630 return 0;
631
632error_tree:
633 remove_proc_subtree(cell->name, net->proc_afs);
634error_dir:
635 _leave(" = -ENOMEM");
636 return -ENOMEM;
637}
638
639/*
640 * remove /proc/fs/afs/<cell>/
641 */
David Howells5b86d4f2018-05-18 11:46:15 +0100642void afs_proc_cell_remove(struct afs_cell *cell)
David Howells10495a02018-05-18 11:46:14 +0100643{
David Howells5b86d4f2018-05-18 11:46:15 +0100644 struct afs_net *net = cell->net;
645
David Howells10495a02018-05-18 11:46:14 +0100646 _enter("");
David Howells10495a02018-05-18 11:46:14 +0100647 remove_proc_subtree(cell->name, net->proc_afs);
David Howells10495a02018-05-18 11:46:14 +0100648 _leave("");
649}
650
651/*
652 * initialise the /proc/fs/afs/ directory
653 */
654int afs_proc_init(struct afs_net *net)
655{
David Howells5b86d4f2018-05-18 11:46:15 +0100656 struct proc_dir_entry *p;
657
David Howells10495a02018-05-18 11:46:14 +0100658 _enter("");
659
David Howells5b86d4f2018-05-18 11:46:15 +0100660 p = proc_net_mkdir(net->net, "afs", net->net->proc_net);
661 if (!p)
David Howells10495a02018-05-18 11:46:14 +0100662 goto error_dir;
663
David Howells5b86d4f2018-05-18 11:46:15 +0100664 if (!proc_create_net_data_write("cells", 0644, p,
665 &afs_proc_cells_ops,
666 afs_proc_cells_write,
667 sizeof(struct seq_net_private),
668 NULL) ||
669 !proc_create_net_single_write("rootcell", 0644, p,
670 afs_proc_rootcell_show,
671 afs_proc_rootcell_write,
672 NULL) ||
673 !proc_create_net("servers", 0444, p, &afs_proc_servers_ops,
674 sizeof(struct seq_net_private)) ||
675 !proc_create_net_single("stats", 0444, p, afs_proc_stats_show, NULL) ||
676 !proc_create_net_data_write("sysname", 0644, p,
677 &afs_proc_sysname_ops,
678 afs_proc_sysname_write,
679 sizeof(struct seq_net_private),
680 NULL))
David Howells10495a02018-05-18 11:46:14 +0100681 goto error_tree;
682
David Howells5b86d4f2018-05-18 11:46:15 +0100683 net->proc_afs = p;
David Howells10495a02018-05-18 11:46:14 +0100684 _leave(" = 0");
685 return 0;
686
687error_tree:
David Howells5b86d4f2018-05-18 11:46:15 +0100688 proc_remove(p);
David Howells10495a02018-05-18 11:46:14 +0100689error_dir:
690 _leave(" = -ENOMEM");
691 return -ENOMEM;
692}
693
694/*
695 * clean up the /proc/fs/afs/ directory
696 */
697void afs_proc_cleanup(struct afs_net *net)
698{
699 proc_remove(net->proc_afs);
700 net->proc_afs = NULL;
701}