proc.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /* /proc interface for AFS
  3. *
  4. * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
  5. * Written by David Howells (dhowells@redhat.com)
  6. */
  7. #include <linux/slab.h>
  8. #include <linux/module.h>
  9. #include <linux/proc_fs.h>
  10. #include <linux/seq_file.h>
  11. #include <linux/sched.h>
  12. #include <linux/uaccess.h>
  13. #include "internal.h"
  14. struct afs_vl_seq_net_private {
  15. struct seq_net_private seq; /* Must be first */
  16. struct afs_vlserver_list *vllist;
  17. };
  18. static inline struct afs_net *afs_seq2net(struct seq_file *m)
  19. {
  20. return afs_net(seq_file_net(m));
  21. }
  22. static inline struct afs_net *afs_seq2net_single(struct seq_file *m)
  23. {
  24. return afs_net(seq_file_single_net(m));
  25. }
  26. /*
  27. * Display the list of cells known to the namespace.
  28. */
  29. static int afs_proc_cells_show(struct seq_file *m, void *v)
  30. {
  31. struct afs_vlserver_list *vllist;
  32. struct afs_cell *cell;
  33. if (v == SEQ_START_TOKEN) {
  34. /* display header on line 1 */
  35. seq_puts(m, "USE ACT TTL SV ST NAME\n");
  36. return 0;
  37. }
  38. cell = list_entry(v, struct afs_cell, proc_link);
  39. vllist = rcu_dereference(cell->vl_servers);
  40. /* display one cell per line on subsequent lines */
  41. seq_printf(m, "%3u %3u %6lld %2u %2u %s\n",
  42. atomic_read(&cell->ref),
  43. atomic_read(&cell->active),
  44. cell->dns_expiry - ktime_get_real_seconds(),
  45. vllist ? vllist->nr_servers : 0,
  46. cell->state,
  47. cell->name);
  48. return 0;
  49. }
  50. static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
  51. __acquires(rcu)
  52. {
  53. rcu_read_lock();
  54. return seq_hlist_start_head_rcu(&afs_seq2net(m)->proc_cells, *_pos);
  55. }
  56. static void *afs_proc_cells_next(struct seq_file *m, void *v, loff_t *pos)
  57. {
  58. return seq_hlist_next_rcu(v, &afs_seq2net(m)->proc_cells, pos);
  59. }
  60. static void afs_proc_cells_stop(struct seq_file *m, void *v)
  61. __releases(rcu)
  62. {
  63. rcu_read_unlock();
  64. }
  65. static const struct seq_operations afs_proc_cells_ops = {
  66. .start = afs_proc_cells_start,
  67. .next = afs_proc_cells_next,
  68. .stop = afs_proc_cells_stop,
  69. .show = afs_proc_cells_show,
  70. };
  71. /*
  72. * handle writes to /proc/fs/afs/cells
  73. * - to add cells: echo "add <cellname> <IP>[:<IP>][:<IP>]"
  74. */
  75. static int afs_proc_cells_write(struct file *file, char *buf, size_t size)
  76. {
  77. struct seq_file *m = file->private_data;
  78. struct afs_net *net = afs_seq2net(m);
  79. char *name, *args;
  80. int ret;
  81. /* trim to first NL */
  82. name = memchr(buf, '\n', size);
  83. if (name)
  84. *name = 0;
  85. /* split into command, name and argslist */
  86. name = strchr(buf, ' ');
  87. if (!name)
  88. goto inval;
  89. do {
  90. *name++ = 0;
  91. } while(*name == ' ');
  92. if (!*name)
  93. goto inval;
  94. args = strchr(name, ' ');
  95. if (args) {
  96. do {
  97. *args++ = 0;
  98. } while(*args == ' ');
  99. if (!*args)
  100. goto inval;
  101. }
  102. /* determine command to perform */
  103. _debug("cmd=%s name=%s args=%s", buf, name, args);
  104. if (strcmp(buf, "add") == 0) {
  105. struct afs_cell *cell;
  106. cell = afs_lookup_cell(net, name, strlen(name), args, true);
  107. if (IS_ERR(cell)) {
  108. ret = PTR_ERR(cell);
  109. goto done;
  110. }
  111. if (test_and_set_bit(AFS_CELL_FL_NO_GC, &cell->flags))
  112. afs_unuse_cell(net, cell, afs_cell_trace_unuse_no_pin);
  113. } else {
  114. goto inval;
  115. }
  116. ret = 0;
  117. done:
  118. _leave(" = %d", ret);
  119. return ret;
  120. inval:
  121. ret = -EINVAL;
  122. printk("kAFS: Invalid Command on /proc/fs/afs/cells file\n");
  123. goto done;
  124. }
  125. /*
  126. * Display the name of the current workstation cell.
  127. */
  128. static int afs_proc_rootcell_show(struct seq_file *m, void *v)
  129. {
  130. struct afs_cell *cell;
  131. struct afs_net *net;
  132. net = afs_seq2net_single(m);
  133. down_read(&net->cells_lock);
  134. cell = net->ws_cell;
  135. if (cell)
  136. seq_printf(m, "%s\n", cell->name);
  137. up_read(&net->cells_lock);
  138. return 0;
  139. }
  140. /*
  141. * Set the current workstation cell and optionally supply its list of volume
  142. * location servers.
  143. *
  144. * echo "cell.name:192.168.231.14" >/proc/fs/afs/rootcell
  145. */
  146. static int afs_proc_rootcell_write(struct file *file, char *buf, size_t size)
  147. {
  148. struct seq_file *m = file->private_data;
  149. struct afs_net *net = afs_seq2net_single(m);
  150. char *s;
  151. int ret;
  152. ret = -EINVAL;
  153. if (buf[0] == '.')
  154. goto out;
  155. if (memchr(buf, '/', size))
  156. goto out;
  157. /* trim to first NL */
  158. s = memchr(buf, '\n', size);
  159. if (s)
  160. *s = 0;
  161. /* determine command to perform */
  162. _debug("rootcell=%s", buf);
  163. ret = afs_cell_init(net, buf);
  164. out:
  165. _leave(" = %d", ret);
  166. return ret;
  167. }
  168. static const char afs_vol_types[3][3] = {
  169. [AFSVL_RWVOL] = "RW",
  170. [AFSVL_ROVOL] = "RO",
  171. [AFSVL_BACKVOL] = "BK",
  172. };
  173. /*
  174. * Display the list of volumes known to a cell.
  175. */
  176. static int afs_proc_cell_volumes_show(struct seq_file *m, void *v)
  177. {
  178. struct afs_volume *vol = hlist_entry(v, struct afs_volume, proc_link);
  179. /* Display header on line 1 */
  180. if (v == SEQ_START_TOKEN) {
  181. seq_puts(m, "USE VID TY NAME\n");
  182. return 0;
  183. }
  184. seq_printf(m, "%3d %08llx %s %s\n",
  185. atomic_read(&vol->usage), vol->vid,
  186. afs_vol_types[vol->type],
  187. vol->name);
  188. return 0;
  189. }
  190. static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
  191. __acquires(cell->proc_lock)
  192. {
  193. struct afs_cell *cell = PDE_DATA(file_inode(m->file));
  194. rcu_read_lock();
  195. return seq_hlist_start_head_rcu(&cell->proc_volumes, *_pos);
  196. }
  197. static void *afs_proc_cell_volumes_next(struct seq_file *m, void *v,
  198. loff_t *_pos)
  199. {
  200. struct afs_cell *cell = PDE_DATA(file_inode(m->file));
  201. return seq_hlist_next_rcu(v, &cell->proc_volumes, _pos);
  202. }
  203. static void afs_proc_cell_volumes_stop(struct seq_file *m, void *v)
  204. __releases(cell->proc_lock)
  205. {
  206. rcu_read_unlock();
  207. }
  208. static const struct seq_operations afs_proc_cell_volumes_ops = {
  209. .start = afs_proc_cell_volumes_start,
  210. .next = afs_proc_cell_volumes_next,
  211. .stop = afs_proc_cell_volumes_stop,
  212. .show = afs_proc_cell_volumes_show,
  213. };
  214. static const char *const dns_record_sources[NR__dns_record_source + 1] = {
  215. [DNS_RECORD_UNAVAILABLE] = "unav",
  216. [DNS_RECORD_FROM_CONFIG] = "cfg",
  217. [DNS_RECORD_FROM_DNS_A] = "A",
  218. [DNS_RECORD_FROM_DNS_AFSDB] = "AFSDB",
  219. [DNS_RECORD_FROM_DNS_SRV] = "SRV",
  220. [DNS_RECORD_FROM_NSS] = "nss",
  221. [NR__dns_record_source] = "[weird]"
  222. };
  223. static const char *const dns_lookup_statuses[NR__dns_lookup_status + 1] = {
  224. [DNS_LOOKUP_NOT_DONE] = "no-lookup",
  225. [DNS_LOOKUP_GOOD] = "good",
  226. [DNS_LOOKUP_GOOD_WITH_BAD] = "good/bad",
  227. [DNS_LOOKUP_BAD] = "bad",
  228. [DNS_LOOKUP_GOT_NOT_FOUND] = "not-found",
  229. [DNS_LOOKUP_GOT_LOCAL_FAILURE] = "local-failure",
  230. [DNS_LOOKUP_GOT_TEMP_FAILURE] = "temp-failure",
  231. [DNS_LOOKUP_GOT_NS_FAILURE] = "ns-failure",
  232. [NR__dns_lookup_status] = "[weird]"
  233. };
  234. /*
  235. * Display the list of Volume Location servers we're using for a cell.
  236. */
  237. static int afs_proc_cell_vlservers_show(struct seq_file *m, void *v)
  238. {
  239. const struct afs_vl_seq_net_private *priv = m->private;
  240. const struct afs_vlserver_list *vllist = priv->vllist;
  241. const struct afs_vlserver_entry *entry;
  242. const struct afs_vlserver *vlserver;
  243. const struct afs_addr_list *alist;
  244. int i;
  245. if (v == SEQ_START_TOKEN) {
  246. seq_printf(m, "# source %s, status %s\n",
  247. dns_record_sources[vllist ? vllist->source : 0],
  248. dns_lookup_statuses[vllist ? vllist->status : 0]);
  249. return 0;
  250. }
  251. entry = v;
  252. vlserver = entry->server;
  253. alist = rcu_dereference(vlserver->addresses);
  254. seq_printf(m, "%s [p=%hu w=%hu s=%s,%s]:\n",
  255. vlserver->name, entry->priority, entry->weight,
  256. dns_record_sources[alist ? alist->source : entry->source],
  257. dns_lookup_statuses[alist ? alist->status : entry->status]);
  258. if (alist) {
  259. for (i = 0; i < alist->nr_addrs; i++)
  260. seq_printf(m, " %c %pISpc\n",
  261. alist->preferred == i ? '>' : '-',
  262. &alist->addrs[i].transport);
  263. }
  264. seq_printf(m, " info: fl=%lx rtt=%d\n", vlserver->flags, vlserver->rtt);
  265. seq_printf(m, " probe: fl=%x e=%d ac=%d out=%d\n",
  266. vlserver->probe.flags, vlserver->probe.error,
  267. vlserver->probe.abort_code,
  268. atomic_read(&vlserver->probe_outstanding));
  269. return 0;
  270. }
  271. static void *afs_proc_cell_vlservers_start(struct seq_file *m, loff_t *_pos)
  272. __acquires(rcu)
  273. {
  274. struct afs_vl_seq_net_private *priv = m->private;
  275. struct afs_vlserver_list *vllist;
  276. struct afs_cell *cell = PDE_DATA(file_inode(m->file));
  277. loff_t pos = *_pos;
  278. rcu_read_lock();
  279. vllist = rcu_dereference(cell->vl_servers);
  280. priv->vllist = vllist;
  281. if (pos < 0)
  282. *_pos = pos = 0;
  283. if (pos == 0)
  284. return SEQ_START_TOKEN;
  285. if (pos - 1 >= vllist->nr_servers)
  286. return NULL;
  287. return &vllist->servers[pos - 1];
  288. }
  289. static void *afs_proc_cell_vlservers_next(struct seq_file *m, void *v,
  290. loff_t *_pos)
  291. {
  292. struct afs_vl_seq_net_private *priv = m->private;
  293. struct afs_vlserver_list *vllist = priv->vllist;
  294. loff_t pos;
  295. pos = *_pos;
  296. pos++;
  297. *_pos = pos;
  298. if (!vllist || pos - 1 >= vllist->nr_servers)
  299. return NULL;
  300. return &vllist->servers[pos - 1];
  301. }
  302. static void afs_proc_cell_vlservers_stop(struct seq_file *m, void *v)
  303. __releases(rcu)
  304. {
  305. rcu_read_unlock();
  306. }
  307. static const struct seq_operations afs_proc_cell_vlservers_ops = {
  308. .start = afs_proc_cell_vlservers_start,
  309. .next = afs_proc_cell_vlservers_next,
  310. .stop = afs_proc_cell_vlservers_stop,
  311. .show = afs_proc_cell_vlservers_show,
  312. };
  313. /*
  314. * Display the list of fileservers we're using within a namespace.
  315. */
  316. static int afs_proc_servers_show(struct seq_file *m, void *v)
  317. {
  318. struct afs_server *server;
  319. struct afs_addr_list *alist;
  320. int i;
  321. if (v == SEQ_START_TOKEN) {
  322. seq_puts(m, "UUID REF ACT\n");
  323. return 0;
  324. }
  325. server = list_entry(v, struct afs_server, proc_link);
  326. alist = rcu_dereference(server->addresses);
  327. seq_printf(m, "%pU %3d %3d\n",
  328. &server->uuid,
  329. atomic_read(&server->ref),
  330. atomic_read(&server->active));
  331. seq_printf(m, " - info: fl=%lx rtt=%u brk=%x\n",
  332. server->flags, server->rtt, server->cb_s_break);
  333. seq_printf(m, " - probe: last=%d out=%d\n",
  334. (int)(jiffies - server->probed_at) / HZ,
  335. atomic_read(&server->probe_outstanding));
  336. seq_printf(m, " - ALIST v=%u rsp=%lx f=%lx\n",
  337. alist->version, alist->responded, alist->failed);
  338. for (i = 0; i < alist->nr_addrs; i++)
  339. seq_printf(m, " [%x] %pISpc%s\n",
  340. i, &alist->addrs[i].transport,
  341. alist->preferred == i ? "*" : "");
  342. return 0;
  343. }
  344. static void *afs_proc_servers_start(struct seq_file *m, loff_t *_pos)
  345. __acquires(rcu)
  346. {
  347. rcu_read_lock();
  348. return seq_hlist_start_head_rcu(&afs_seq2net(m)->fs_proc, *_pos);
  349. }
  350. static void *afs_proc_servers_next(struct seq_file *m, void *v, loff_t *_pos)
  351. {
  352. return seq_hlist_next_rcu(v, &afs_seq2net(m)->fs_proc, _pos);
  353. }
  354. static void afs_proc_servers_stop(struct seq_file *m, void *v)
  355. __releases(rcu)
  356. {
  357. rcu_read_unlock();
  358. }
  359. static const struct seq_operations afs_proc_servers_ops = {
  360. .start = afs_proc_servers_start,
  361. .next = afs_proc_servers_next,
  362. .stop = afs_proc_servers_stop,
  363. .show = afs_proc_servers_show,
  364. };
  365. /*
  366. * Display the list of strings that may be substituted for the @sys pathname
  367. * macro.
  368. */
  369. static int afs_proc_sysname_show(struct seq_file *m, void *v)
  370. {
  371. struct afs_net *net = afs_seq2net(m);
  372. struct afs_sysnames *sysnames = net->sysnames;
  373. unsigned int i = (unsigned long)v - 1;
  374. if (i < sysnames->nr)
  375. seq_printf(m, "%s\n", sysnames->subs[i]);
  376. return 0;
  377. }
  378. static void *afs_proc_sysname_start(struct seq_file *m, loff_t *pos)
  379. __acquires(&net->sysnames_lock)
  380. {
  381. struct afs_net *net = afs_seq2net(m);
  382. struct afs_sysnames *names;
  383. read_lock(&net->sysnames_lock);
  384. names = net->sysnames;
  385. if (*pos >= names->nr)
  386. return NULL;
  387. return (void *)(unsigned long)(*pos + 1);
  388. }
  389. static void *afs_proc_sysname_next(struct seq_file *m, void *v, loff_t *pos)
  390. {
  391. struct afs_net *net = afs_seq2net(m);
  392. struct afs_sysnames *names = net->sysnames;
  393. *pos += 1;
  394. if (*pos >= names->nr)
  395. return NULL;
  396. return (void *)(unsigned long)(*pos + 1);
  397. }
  398. static void afs_proc_sysname_stop(struct seq_file *m, void *v)
  399. __releases(&net->sysnames_lock)
  400. {
  401. struct afs_net *net = afs_seq2net(m);
  402. read_unlock(&net->sysnames_lock);
  403. }
  404. static const struct seq_operations afs_proc_sysname_ops = {
  405. .start = afs_proc_sysname_start,
  406. .next = afs_proc_sysname_next,
  407. .stop = afs_proc_sysname_stop,
  408. .show = afs_proc_sysname_show,
  409. };
  410. /*
  411. * Allow the @sys substitution to be configured.
  412. */
  413. static int afs_proc_sysname_write(struct file *file, char *buf, size_t size)
  414. {
  415. struct afs_sysnames *sysnames, *kill;
  416. struct seq_file *m = file->private_data;
  417. struct afs_net *net = afs_seq2net(m);
  418. char *s, *p, *sub;
  419. int ret, len;
  420. sysnames = kzalloc(sizeof(*sysnames), GFP_KERNEL);
  421. if (!sysnames)
  422. return -ENOMEM;
  423. refcount_set(&sysnames->usage, 1);
  424. kill = sysnames;
  425. p = buf;
  426. while ((s = strsep(&p, " \t\n"))) {
  427. len = strlen(s);
  428. if (len == 0)
  429. continue;
  430. ret = -ENAMETOOLONG;
  431. if (len >= AFSNAMEMAX)
  432. goto error;
  433. if (len >= 4 &&
  434. s[len - 4] == '@' &&
  435. s[len - 3] == 's' &&
  436. s[len - 2] == 'y' &&
  437. s[len - 1] == 's')
  438. /* Protect against recursion */
  439. goto invalid;
  440. if (s[0] == '.' &&
  441. (len < 2 || (len == 2 && s[1] == '.')))
  442. goto invalid;
  443. if (memchr(s, '/', len))
  444. goto invalid;
  445. ret = -EFBIG;
  446. if (sysnames->nr >= AFS_NR_SYSNAME)
  447. goto out;
  448. if (strcmp(s, afs_init_sysname) == 0) {
  449. sub = (char *)afs_init_sysname;
  450. } else {
  451. ret = -ENOMEM;
  452. sub = kmemdup(s, len + 1, GFP_KERNEL);
  453. if (!sub)
  454. goto out;
  455. }
  456. sysnames->subs[sysnames->nr] = sub;
  457. sysnames->nr++;
  458. }
  459. if (sysnames->nr == 0) {
  460. sysnames->subs[0] = sysnames->blank;
  461. sysnames->nr++;
  462. }
  463. write_lock(&net->sysnames_lock);
  464. kill = net->sysnames;
  465. net->sysnames = sysnames;
  466. write_unlock(&net->sysnames_lock);
  467. ret = 0;
  468. out:
  469. afs_put_sysnames(kill);
  470. return ret;
  471. invalid:
  472. ret = -EINVAL;
  473. error:
  474. goto out;
  475. }
  476. void afs_put_sysnames(struct afs_sysnames *sysnames)
  477. {
  478. int i;
  479. if (sysnames && refcount_dec_and_test(&sysnames->usage)) {
  480. for (i = 0; i < sysnames->nr; i++)
  481. if (sysnames->subs[i] != afs_init_sysname &&
  482. sysnames->subs[i] != sysnames->blank)
  483. kfree(sysnames->subs[i]);
  484. kfree(sysnames);
  485. }
  486. }
  487. /*
  488. * Display general per-net namespace statistics
  489. */
  490. static int afs_proc_stats_show(struct seq_file *m, void *v)
  491. {
  492. struct afs_net *net = afs_seq2net_single(m);
  493. seq_puts(m, "kAFS statistics\n");
  494. seq_printf(m, "dir-mgmt: look=%u reval=%u inval=%u relpg=%u\n",
  495. atomic_read(&net->n_lookup),
  496. atomic_read(&net->n_reval),
  497. atomic_read(&net->n_inval),
  498. atomic_read(&net->n_relpg));
  499. seq_printf(m, "dir-data: rdpg=%u\n",
  500. atomic_read(&net->n_read_dir));
  501. seq_printf(m, "dir-edit: cr=%u rm=%u\n",
  502. atomic_read(&net->n_dir_cr),
  503. atomic_read(&net->n_dir_rm));
  504. seq_printf(m, "file-rd : n=%u nb=%lu\n",
  505. atomic_read(&net->n_fetches),
  506. atomic_long_read(&net->n_fetch_bytes));
  507. seq_printf(m, "file-wr : n=%u nb=%lu\n",
  508. atomic_read(&net->n_stores),
  509. atomic_long_read(&net->n_store_bytes));
  510. return 0;
  511. }
  512. /*
  513. * initialise /proc/fs/afs/<cell>/
  514. */
  515. int afs_proc_cell_setup(struct afs_cell *cell)
  516. {
  517. struct proc_dir_entry *dir;
  518. struct afs_net *net = cell->net;
  519. _enter("%p{%s},%p", cell, cell->name, net->proc_afs);
  520. dir = proc_net_mkdir(net->net, cell->name, net->proc_afs);
  521. if (!dir)
  522. goto error_dir;
  523. if (!proc_create_net_data("vlservers", 0444, dir,
  524. &afs_proc_cell_vlservers_ops,
  525. sizeof(struct afs_vl_seq_net_private),
  526. cell) ||
  527. !proc_create_net_data("volumes", 0444, dir,
  528. &afs_proc_cell_volumes_ops,
  529. sizeof(struct seq_net_private),
  530. cell))
  531. goto error_tree;
  532. _leave(" = 0");
  533. return 0;
  534. error_tree:
  535. remove_proc_subtree(cell->name, net->proc_afs);
  536. error_dir:
  537. _leave(" = -ENOMEM");
  538. return -ENOMEM;
  539. }
  540. /*
  541. * remove /proc/fs/afs/<cell>/
  542. */
  543. void afs_proc_cell_remove(struct afs_cell *cell)
  544. {
  545. struct afs_net *net = cell->net;
  546. _enter("");
  547. remove_proc_subtree(cell->name, net->proc_afs);
  548. _leave("");
  549. }
  550. /*
  551. * initialise the /proc/fs/afs/ directory
  552. */
  553. int afs_proc_init(struct afs_net *net)
  554. {
  555. struct proc_dir_entry *p;
  556. _enter("");
  557. p = proc_net_mkdir(net->net, "afs", net->net->proc_net);
  558. if (!p)
  559. goto error_dir;
  560. if (!proc_create_net_data_write("cells", 0644, p,
  561. &afs_proc_cells_ops,
  562. afs_proc_cells_write,
  563. sizeof(struct seq_net_private),
  564. NULL) ||
  565. !proc_create_net_single_write("rootcell", 0644, p,
  566. afs_proc_rootcell_show,
  567. afs_proc_rootcell_write,
  568. NULL) ||
  569. !proc_create_net("servers", 0444, p, &afs_proc_servers_ops,
  570. sizeof(struct seq_net_private)) ||
  571. !proc_create_net_single("stats", 0444, p, afs_proc_stats_show, NULL) ||
  572. !proc_create_net_data_write("sysname", 0644, p,
  573. &afs_proc_sysname_ops,
  574. afs_proc_sysname_write,
  575. sizeof(struct seq_net_private),
  576. NULL))
  577. goto error_tree;
  578. net->proc_afs = p;
  579. _leave(" = 0");
  580. return 0;
  581. error_tree:
  582. proc_remove(p);
  583. error_dir:
  584. _leave(" = -ENOMEM");
  585. return -ENOMEM;
  586. }
  587. /*
  588. * clean up the /proc/fs/afs/ directory
  589. */
  590. void afs_proc_cleanup(struct afs_net *net)
  591. {
  592. proc_remove(net->proc_afs);
  593. net->proc_afs = NULL;
  594. }