aboutsummaryrefslogblamecommitdiffstats
path: root/include/asm-mips/prctl.h
blob: 4aaaff670361da5b5c145219fc3d37c3246c0851 (plain) (tree)








































                                                                                   
/*
 * IRIX prctl interface
 *
 * The IRIX kernel maps a page at PRDA_ADDRESS with the
 * contents of prda and fills it the bits on prda_sys.
 */

#ifndef __PRCTL_H__
#define __PRCTL_H__

#define PRDA_ADDRESS 0x200000L
#define PRDA ((struct prda *) PRDA_ADDRESS)

struct prda_sys {
	pid_t t_pid;
        u32   t_hint;
        u32   t_dlactseq;
        u32   t_fpflags;
        u32   t_prid;		/* processor type, $prid CP0 register */
        u32   t_dlendseq;
        u64   t_unused1[5];
        pid_t t_rpid;
        s32   t_resched;
        u32   t_unused[8];
        u32   t_cpu;		/* current/last cpu */

	/* FIXME: The signal information, not supported by Linux now */
	u32   t_flags;		/* if true, then the sigprocmask is in userspace */
	u32   t_sigprocmask [1]; /* the sigprocmask */
};

struct prda {
	char fill [0xe00];
	struct prda_sys prda_sys;
};

#define t_sys           prda_sys

ptrdiff_t prctl (int op, int v1, int v2);

#endif
6 15:00:07 -0400 SL*B: drop kmem cache argument from constructor' href='/cgit/cgit.cgi/litmus-rt.git/commit/fs/afs/super.c?h=prop/litmus-signals&id=51cc50685a4275c6a02653670af9f108a64e01cf'>51cc50685a42
f7442b3be65b

dde194a64bb5
1da177e4c3f4
1da177e4c3f4
45222b9e02fb
1da177e4c3f4
1f5ce9e93aa9
1da177e4c3f4

f7442b3be65b
dde194a64bb5
80c72fe41569
1da177e4c3f4

ee9b6d61a2a4
45222b9e02fb
1da177e4c3f4
bec5eb614130
1da177e4c3f4
b57922d97fd6
969729d56ef2
1da177e4c3f4

e18b890bb088
1da177e4c3f4

80c72fe41569




bec5eb614130
80c72fe41569

a447c0932445
80c72fe41569


bec5eb614130
80c72fe41569


1da177e4c3f4








1da177e4c3f4







20c2df83d25c
1da177e4c3f4








08e0e7c82eea
1da177e4c3f4


08e0e7c82eea
1da177e4c3f4
ec26815ad847
1da177e4c3f4
1da177e4c3f4




08e0e7c82eea


1da177e4c3f4








08e0e7c82eea
ec26815ad847
1da177e4c3f4
1da177e4c3f4
1da177e4c3f4



00d3b7a4533e

1da177e4c3f4
08e0e7c82eea
80c72fe41569


1da177e4c3f4




80c72fe41569


1da177e4c3f4
80c72fe41569



bec5eb614130

08e0e7c82eea

00d3b7a4533e

80c72fe41569









bec5eb614130



80c72fe41569



1da177e4c3f4
1da177e4c3f4

80c72fe41569

ec26815ad847
1da177e4c3f4
1da177e4c3f4
00d3b7a4533e









































































bec5eb614130
00d3b7a4533e
bec5eb614130

00d3b7a4533e














1da177e4c3f4



dde194a64bb5
1da177e4c3f4

dde194a64bb5






ec26815ad847
1da177e4c3f4
1da177e4c3f4


dde194a64bb5

1da177e4c3f4
dde194a64bb5
1da177e4c3f4




08e0e7c82eea
1da177e4c3f4
1da177e4c3f4




e1da0222753a
2e41ae225f74
1da177e4c3f4




260a980317da
08e0e7c82eea
dde194a64bb5
1da177e4c3f4
bec5eb614130


1da177e4c3f4




d61dcce2977d
1da177e4c3f4

08e0e7c82eea
1da177e4c3f4

ec26815ad847
1da177e4c3f4
08e0e7c82eea
1da177e4c3f4
ec26815ad847
1da177e4c3f4
1da177e4c3f4

1da177e4c3f4
f7442b3be65b

1da177e4c3f4


08e0e7c82eea
00d3b7a4533e
969729d56ef2
dde194a64bb5
1da177e4c3f4





00d3b7a4533e
1da177e4c3f4
00d3b7a4533e
1da177e4c3f4

1da177e4c3f4

00d3b7a4533e












1da177e4c3f4
00d3b7a4533e
08e0e7c82eea

1da177e4c3f4
08e0e7c82eea
dde194a64bb5








1da177e4c3f4

dde194a64bb5
08e0e7c82eea

dde194a64bb5

1da177e4c3f4
08e0e7c82eea
1da177e4c3f4
436058a49e0f





6f5bbff9a1b7
436058a49e0f

2a32cebd6cbc
436058a49e0f



dde194a64bb5

1da177e4c3f4
1da177e4c3f4
00d3b7a4533e
2a32cebd6cbc
08e0e7c82eea
f7442b3be65b
1da177e4c3f4
ec26815ad847
00d3b7a4533e

969729d56ef2
1da177e4c3f4
f7442b3be65b
ec26815ad847
1da177e4c3f4
dde194a64bb5
1da177e4c3f4

dde194a64bb5
1da177e4c3f4
dde194a64bb5
ec26815ad847
1da177e4c3f4
1da177e4c3f4


51cc50685a42
1da177e4c3f4
ec26815ad847
1da177e4c3f4
a35afb830f8d







e8d6c554126b


a35afb830f8d
ec26815ad847
1da177e4c3f4
1da177e4c3f4






ec26815ad847
1da177e4c3f4









260a980317da
08e0e7c82eea
1da177e4c3f4
0f300ca9284c
1da177e4c3f4
ec26815ad847
1da177e4c3f4
fa0d7e3de6d6







1da177e4c3f4




08e0e7c82eea

0f300ca9284c
1da177e4c3f4
08e0e7c82eea



fa0d7e3de6d6
1da177e4c3f4
ec26815ad847
45222b9e02fb
































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
88
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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
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
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550

                          
                                                              








                                                                    
                                                 




                         
                        



                          
                         
                         
                        



                                            
                                       

                                                                   
                                                   
                                                             
                                                   
                                                                  
 
                                       

                                      
                                    
                                         
                            

  
                                                      
                                     
                                          
                                         
                                            
                                          
                                               

  
                                           

                                        




                       
                         

  
                                               


                                                  
                                                  


                                                  








                            







                                                                      
                                                              








                                                                             
                                     


                           
                       
                 
 
 




                             


                               








                                                                       
                   
 
 
  



                                                                      

                                                                 
 
                              


                                       




                                   


                                             
 



                                                               

                                                                         

                                                     

                                                   









                                                



                                             



                                                                              
                 

         

                       
 
 
  









































































                                                                         
                                                                   
                                   

                                                                                














                                                                           



                                                              
                                          

                                                  






                                                            
 
 


                         

                                                          
 
                                                  




                                   
                   
 




                                                   
                                                   
                                                                              




                                                
                                                            
                          
                                      
 


                                                                     




                                   
                                               

                          
                       

                 
      
                    
                             
                   
 
 

                        
   

                                                                     


                                       
                               
                        
                                                      
                                  





                                             
                                               
                      
                                                                     

                                   

         












                                                       
                                   
                                         

                                   
                           
         








                                                                

                                              
                                                              

                                  

                                    
                           
         
 





                                                      
                                                    

                                   
                                                 



                                                     

                                    
         
 
                                  
                        
                                
                                
 
      

                                  
                        
                             
                            
 
 
                                                  

                                                  
                            
                                   
                  
 
 


                                                          
                                         
 
                                         
 







                                                  


                                                            
                                                                    
 
 






                                                            
                                                               









                                                         
                                                       
                                        
 
                                           
                                 
 
 







                                                                      




                                                  

                                                  
                                                                     
 



                                           
                                                
                                             
 
































                                                                        
/* AFS superblock handling
 *
 * Copyright (c) 2002, 2007 Red Hat, Inc. All rights reserved.
 *
 * This software may be freely redistributed under the terms of the
 * GNU General Public License.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * Authors: David Howells <dhowells@redhat.com>
 *          David Woodhouse <dwmw2@infradead.org>
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mount.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/parser.h>
#include <linux/statfs.h>
#include <linux/sched.h>
#include "internal.h"

#define AFS_FS_MAGIC 0x6B414653 /* 'kAFS' */

static void afs_i_init_once(void *foo);
static struct dentry *afs_mount(struct file_system_type *fs_type,
		      int flags, const char *dev_name, void *data);
static void afs_kill_super(struct super_block *sb);
static struct inode *afs_alloc_inode(struct super_block *sb);
static void afs_destroy_inode(struct inode *inode);
static int afs_statfs(struct dentry *dentry, struct kstatfs *buf);

struct file_system_type afs_fs_type = {
	.owner		= THIS_MODULE,
	.name		= "afs",
	.mount		= afs_mount,
	.kill_sb	= afs_kill_super,
	.fs_flags	= 0,
};

static const struct super_operations afs_super_ops = {
	.statfs		= afs_statfs,
	.alloc_inode	= afs_alloc_inode,
	.drop_inode	= afs_drop_inode,
	.destroy_inode	= afs_destroy_inode,
	.evict_inode	= afs_evict_inode,
	.show_options	= generic_show_options,
};

static struct kmem_cache *afs_inode_cachep;
static atomic_t afs_count_active_inodes;

enum {
	afs_no_opt,
	afs_opt_cell,
	afs_opt_rwpath,
	afs_opt_vol,
	afs_opt_autocell,
};

static const match_table_t afs_options_list = {
	{ afs_opt_cell,		"cell=%s"	},
	{ afs_opt_rwpath,	"rwpath"	},
	{ afs_opt_vol,		"vol=%s"	},
	{ afs_opt_autocell,	"autocell"	},
	{ afs_no_opt,		NULL		},
};

/*
 * initialise the filesystem
 */
int __init afs_fs_init(void)
{
	int ret;

	_enter("");

	/* create ourselves an inode cache */
	atomic_set(&afs_count_active_inodes, 0);

	ret = -ENOMEM;
	afs_inode_cachep = kmem_cache_create("afs_inode_cache",
					     sizeof(struct afs_vnode),
					     0,
					     SLAB_HWCACHE_ALIGN,
					     afs_i_init_once);
	if (!afs_inode_cachep) {
		printk(KERN_NOTICE "kAFS: Failed to allocate inode cache\n");
		return ret;
	}

	/* now export our filesystem to lesser mortals */
	ret = register_filesystem(&afs_fs_type);
	if (ret < 0) {
		kmem_cache_destroy(afs_inode_cachep);
		_leave(" = %d", ret);
		return ret;
	}

	_leave(" = 0");
	return 0;
}

/*
 * clean up the filesystem
 */
void __exit afs_fs_exit(void)
{
	_enter("");

	afs_mntpt_kill_timer();
	unregister_filesystem(&afs_fs_type);

	if (atomic_read(&afs_count_active_inodes) != 0) {
		printk("kAFS: %d active inode objects still present\n",
		       atomic_read(&afs_count_active_inodes));
		BUG();
	}

	kmem_cache_destroy(afs_inode_cachep);
	_leave("");
}

/*
 * parse the mount options
 * - this function has been shamelessly adapted from the ext3 fs which
 *   shamelessly adapted it from the msdos fs
 */
static int afs_parse_options(struct afs_mount_params *params,
			     char *options, const char **devname)
{
	struct afs_cell *cell;
	substring_t args[MAX_OPT_ARGS];
	char *p;
	int token;

	_enter("%s", options);

	options[PAGE_SIZE - 1] = 0;

	while ((p = strsep(&options, ","))) {
		if (!*p)
			continue;

		token = match_token(p, afs_options_list, args);
		switch (token) {
		case afs_opt_cell:
			cell = afs_cell_lookup(args[0].from,
					       args[0].to - args[0].from,
					       false);
			if (IS_ERR(cell))
				return PTR_ERR(cell);
			afs_put_cell(params->cell);
			params->cell = cell;
			break;

		case afs_opt_rwpath:
			params->rwpath = 1;
			break;

		case afs_opt_vol:
			*devname = args[0].from;
			break;

		case afs_opt_autocell:
			params->autocell = 1;
			break;

		default:
			printk(KERN_ERR "kAFS:"
			       " Unknown or invalid mount option: '%s'\n", p);
			return -EINVAL;
		}
	}

	_leave(" = 0");
	return 0;
}

/*
 * parse a device name to get cell name, volume name, volume type and R/W
 * selector
 * - this can be one of the following:
 *	"%[cell:]volume[.]"		R/W volume
 *	"#[cell:]volume[.]"		R/O or R/W volume (rwpath=0),
 *					 or R/W (rwpath=1) volume
 *	"%[cell:]volume.readonly"	R/O volume
 *	"#[cell:]volume.readonly"	R/O volume
 *	"%[cell:]volume.backup"		Backup volume
 *	"#[cell:]volume.backup"		Backup volume
 */
static int afs_parse_device_name(struct afs_mount_params *params,
				 const char *name)
{
	struct afs_cell *cell;
	const char *cellname, *suffix;
	int cellnamesz;

	_enter(",%s", name);

	if (!name) {
		printk(KERN_ERR "kAFS: no volume name specified\n");
		return -EINVAL;
	}

	if ((name[0] != '%' && name[0] != '#') || !name[1]) {
		printk(KERN_ERR "kAFS: unparsable volume name\n");
		return -EINVAL;
	}

	/* determine the type of volume we're looking for */
	params->type = AFSVL_ROVOL;
	params->force = false;
	if (params->rwpath || name[0] == '%') {
		params->type = AFSVL_RWVOL;
		params->force = true;
	}
	name++;

	/* split the cell name out if there is one */
	params->volname = strchr(name, ':');
	if (params->volname) {
		cellname = name;
		cellnamesz = params->volname - name;
		params->volname++;
	} else {
		params->volname = name;
		cellname = NULL;
		cellnamesz = 0;
	}

	/* the volume type is further affected by a possible suffix */
	suffix = strrchr(params->volname, '.');
	if (suffix) {
		if (strcmp(suffix, ".readonly") == 0) {
			params->type = AFSVL_ROVOL;
			params->force = true;
		} else if (strcmp(suffix, ".backup") == 0) {
			params->type = AFSVL_BACKVOL;
			params->force = true;
		} else if (suffix[1] == 0) {
		} else {
			suffix = NULL;
		}
	}

	params->volnamesz = suffix ?
		suffix - params->volname : strlen(params->volname);

	_debug("cell %*.*s [%p]",
	       cellnamesz, cellnamesz, cellname ?: "", params->cell);

	/* lookup the cell record */
	if (cellname || !params->cell) {
		cell = afs_cell_lookup(cellname, cellnamesz, true);
		if (IS_ERR(cell)) {
			printk(KERN_ERR "kAFS: unable to lookup cell '%*.*s'\n",
			       cellnamesz, cellnamesz, cellname ?: "");
			return PTR_ERR(cell);
		}
		afs_put_cell(params->cell);
		params->cell = cell;
	}

	_debug("CELL:%s [%p] VOLUME:%*.*s SUFFIX:%s TYPE:%d%s",
	       params->cell->name, params->cell,
	       params->volnamesz, params->volnamesz, params->volname,
	       suffix ?: "-", params->type, params->force ? " FORCE" : "");

	return 0;
}

/*
 * check a superblock to see if it's the one we're looking for
 */
static int afs_test_super(struct super_block *sb, void *data)
{
	struct afs_super_info *as1 = data;
	struct afs_super_info *as = sb->s_fs_info;

	return as->volume == as1->volume;
}

static int afs_set_super(struct super_block *sb, void *data)
{
	sb->s_fs_info = data;
	return set_anon_super(sb, NULL);
}

/*
 * fill in the superblock
 */
static int afs_fill_super(struct super_block *sb,
			  struct afs_mount_params *params)
{
	struct afs_super_info *as = sb->s_fs_info;
	struct afs_fid fid;
	struct dentry *root = NULL;
	struct inode *inode = NULL;
	int ret;

	_enter("");

	/* fill in the superblock */
	sb->s_blocksize		= PAGE_CACHE_SIZE;
	sb->s_blocksize_bits	= PAGE_CACHE_SHIFT;
	sb->s_magic		= AFS_FS_MAGIC;
	sb->s_op		= &afs_super_ops;
	sb->s_bdi		= &as->volume->bdi;
	strlcpy(sb->s_id, as->volume->vlocation->vldb.name, sizeof(sb->s_id));

	/* allocate the root inode and dentry */
	fid.vid		= as->volume->vid;
	fid.vnode	= 1;
	fid.unique	= 1;
	inode = afs_iget(sb, params->key, &fid, NULL, NULL);
	if (IS_ERR(inode))
		return PTR_ERR(inode);

	if (params->autocell)
		set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags);

	ret = -ENOMEM;
	root = d_alloc_root(inode);
	if (!root)
		goto error;

	sb->s_d_op = &afs_fs_dentry_operations;
	sb->s_root = root;

	_leave(" = 0");
	return 0;

error:
	iput(inode);
	_leave(" = %d", ret);
	return ret;
}

/*
 * get an AFS superblock
 */
static struct dentry *afs_mount(struct file_system_type *fs_type,
		      int flags, const char *dev_name, void *options)
{
	struct afs_mount_params params;
	struct super_block *sb;
	struct afs_volume *vol;
	struct key *key;
	char *new_opts = kstrdup(options, GFP_KERNEL);
	struct afs_super_info *as;
	int ret;

	_enter(",,%s,%p", dev_name, options);

	memset(&params, 0, sizeof(params));

	/* parse the options and device name */
	if (options) {
		ret = afs_parse_options(&params, options, &dev_name);
		if (ret < 0)
			goto error;
	}

	ret = afs_parse_device_name(&params, dev_name);
	if (ret < 0)
		goto error;

	/* try and do the mount securely */
	key = afs_request_key(params.cell);
	if (IS_ERR(key)) {
		_leave(" = %ld [key]", PTR_ERR(key));
		ret = PTR_ERR(key);
		goto error;
	}
	params.key = key;

	/* parse the device name */
	vol = afs_volume_lookup(&params);
	if (IS_ERR(vol)) {
		ret = PTR_ERR(vol);
		goto error;
	}

	/* allocate a superblock info record */
	as = kzalloc(sizeof(struct afs_super_info), GFP_KERNEL);
	if (!as) {
		ret = -ENOMEM;
		afs_put_volume(vol);
		goto error;
	}
	as->volume = vol;

	/* allocate a deviceless superblock */
	sb = sget(fs_type, afs_test_super, afs_set_super, as);
	if (IS_ERR(sb)) {
		ret = PTR_ERR(sb);
		afs_put_volume(vol);
		kfree(as);
		goto error;
	}

	if (!sb->s_root) {
		/* initial superblock/root creation */
		_debug("create");
		sb->s_flags = flags;
		ret = afs_fill_super(sb, &params);
		if (ret < 0) {
			deactivate_locked_super(sb);
			goto error;
		}
		save_mount_options(sb, new_opts);
		sb->s_flags |= MS_ACTIVE;
	} else {
		_debug("reuse");
		ASSERTCMP(sb->s_flags, &, MS_ACTIVE);
		afs_put_volume(vol);
		kfree(as);
	}

	afs_put_cell(params.cell);
	kfree(new_opts);
	_leave(" = 0 [%p]", sb);
	return dget(sb->s_root);

error:
	afs_put_cell(params.cell);
	key_put(params.key);
	kfree(new_opts);
	_leave(" = %d", ret);
	return ERR_PTR(ret);
}

static void afs_kill_super(struct super_block *sb)
{
	struct afs_super_info *as = sb->s_fs_info;
	kill_anon_super(sb);
	afs_put_volume(as->volume);
	kfree(as);
}

/*
 * initialise an inode cache slab element prior to any use
 */
static void afs_i_init_once(void *_vnode)
{
	struct afs_vnode *vnode = _vnode;

	memset(vnode, 0, sizeof(*vnode));
	inode_init_once(&vnode->vfs_inode);
	init_waitqueue_head(&vnode->update_waitq);
	mutex_init(&vnode->permits_lock);
	mutex_init(&vnode->validate_lock);
	spin_lock_init(&vnode->writeback_lock);
	spin_lock_init(&vnode->lock);
	INIT_LIST_HEAD(&vnode->writebacks);
	INIT_LIST_HEAD(&vnode->pending_locks);
	INIT_LIST_HEAD(&vnode->granted_locks);
	INIT_DELAYED_WORK(&vnode->lock_work, afs_lock_work);
	INIT_WORK(&vnode->cb_broken_work, afs_broken_callback_work);
}

/*
 * allocate an AFS inode struct from our slab cache
 */
static struct inode *afs_alloc_inode(struct super_block *sb)
{
	struct afs_vnode *vnode;

	vnode = kmem_cache_alloc(afs_inode_cachep, GFP_KERNEL);
	if (!vnode)
		return NULL;

	atomic_inc(&afs_count_active_inodes);

	memset(&vnode->fid, 0, sizeof(vnode->fid));
	memset(&vnode->status, 0, sizeof(vnode->status));

	vnode->volume		= NULL;
	vnode->update_cnt	= 0;
	vnode->flags		= 1 << AFS_VNODE_UNSET;
	vnode->cb_promised	= false;

	_leave(" = %p", &vnode->vfs_inode);
	return &vnode->vfs_inode;
}

static void afs_i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);
	struct afs_vnode *vnode = AFS_FS_I(inode);
	INIT_LIST_HEAD(&inode->i_dentry);
	kmem_cache_free(afs_inode_cachep, vnode);
}

/*
 * destroy an AFS inode struct
 */
static void afs_destroy_inode(struct inode *inode)
{
	struct afs_vnode *vnode = AFS_FS_I(inode);

	_enter("%p{%x:%u}", inode, vnode->fid.vid, vnode->fid.vnode);

	_debug("DESTROY INODE %p", inode);

	ASSERTCMP(vnode->server, ==, NULL);

	call_rcu(&inode->i_rcu, afs_i_callback);
	atomic_dec(&afs_count_active_inodes);
}

/*
 * return information about an AFS volume
 */
static int afs_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct afs_volume_status vs;
	struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
	struct key *key;
	int ret;

	key = afs_request_key(vnode->volume->cell);
	if (IS_ERR(key))
		return PTR_ERR(key);

	ret = afs_vnode_get_volume_status(vnode, key, &vs);
	key_put(key);
	if (ret < 0) {
		_leave(" = %d", ret);
		return ret;
	}

	buf->f_type	= dentry->d_sb->s_magic;
	buf->f_bsize	= AFS_BLOCK_SIZE;
	buf->f_namelen	= AFSNAMEMAX - 1;

	if (vs.max_quota == 0)
		buf->f_blocks = vs.part_max_blocks;
	else
		buf->f_blocks = vs.max_quota;
	buf->f_bavail = buf->f_bfree = buf->f_blocks - vs.blocks_in_use;
	return 0;
}