← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to fs/afs/internal.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/afs/internal.h
 
1
/* internal AFS stuff
 
2
 *
 
3
 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
 
4
 * Written by David Howells (dhowells@redhat.com)
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU General Public License
 
8
 * as published by the Free Software Foundation; either version
 
9
 * 2 of the License, or (at your option) any later version.
 
10
 */
 
11
 
 
12
#include <linux/compiler.h>
 
13
#include <linux/kernel.h>
 
14
#include <linux/fs.h>
 
15
#include <linux/pagemap.h>
 
16
#include <linux/skbuff.h>
 
17
#include <linux/rxrpc.h>
 
18
#include <linux/key.h>
 
19
#include <linux/workqueue.h>
 
20
#include <linux/sched.h>
 
21
#include <linux/fscache.h>
 
22
#include <linux/backing-dev.h>
 
23
 
 
24
#include "afs.h"
 
25
#include "afs_vl.h"
 
26
 
 
27
#define AFS_CELL_MAX_ADDRS 15
 
28
 
 
29
struct pagevec;
 
30
struct afs_call;
 
31
 
 
32
typedef enum {
 
33
        AFS_VL_NEW,                     /* new, uninitialised record */
 
34
        AFS_VL_CREATING,                /* creating record */
 
35
        AFS_VL_VALID,                   /* record is pending */
 
36
        AFS_VL_NO_VOLUME,               /* no such volume available */
 
37
        AFS_VL_UPDATING,                /* update in progress */
 
38
        AFS_VL_VOLUME_DELETED,          /* volume was deleted */
 
39
        AFS_VL_UNCERTAIN,               /* uncertain state (update failed) */
 
40
} __attribute__((packed)) afs_vlocation_state_t;
 
41
 
 
42
struct afs_mount_params {
 
43
        bool                    rwpath;         /* T if the parent should be considered R/W */
 
44
        bool                    force;          /* T to force cell type */
 
45
        bool                    autocell;       /* T if set auto mount operation */
 
46
        afs_voltype_t           type;           /* type of volume requested */
 
47
        int                     volnamesz;      /* size of volume name */
 
48
        const char              *volname;       /* name of volume to mount */
 
49
        struct afs_cell         *cell;          /* cell in which to find volume */
 
50
        struct afs_volume       *volume;        /* volume record */
 
51
        struct key              *key;           /* key to use for secure mounting */
 
52
};
 
53
 
 
54
/*
 
55
 * definition of how to wait for the completion of an operation
 
56
 */
 
57
struct afs_wait_mode {
 
58
        /* RxRPC received message notification */
 
59
        void (*rx_wakeup)(struct afs_call *call);
 
60
 
 
61
        /* synchronous call waiter and call dispatched notification */
 
62
        int (*wait)(struct afs_call *call);
 
63
 
 
64
        /* asynchronous call completion */
 
65
        void (*async_complete)(void *reply, int error);
 
66
};
 
67
 
 
68
extern const struct afs_wait_mode afs_sync_call;
 
69
extern const struct afs_wait_mode afs_async_call;
 
70
 
 
71
/*
 
72
 * a record of an in-progress RxRPC call
 
73
 */
 
74
struct afs_call {
 
75
        const struct afs_call_type *type;       /* type of call */
 
76
        const struct afs_wait_mode *wait_mode;  /* completion wait mode */
 
77
        wait_queue_head_t       waitq;          /* processes awaiting completion */
 
78
        struct work_struct      async_work;     /* asynchronous work processor */
 
79
        struct work_struct      work;           /* actual work processor */
 
80
        struct sk_buff_head     rx_queue;       /* received packets */
 
81
        struct rxrpc_call       *rxcall;        /* RxRPC call handle */
 
82
        struct key              *key;           /* security for this call */
 
83
        struct afs_server       *server;        /* server affected by incoming CM call */
 
84
        void                    *request;       /* request data (first part) */
 
85
        struct address_space    *mapping;       /* page set */
 
86
        struct afs_writeback    *wb;            /* writeback being performed */
 
87
        void                    *buffer;        /* reply receive buffer */
 
88
        void                    *reply;         /* reply buffer (first part) */
 
89
        void                    *reply2;        /* reply buffer (second part) */
 
90
        void                    *reply3;        /* reply buffer (third part) */
 
91
        void                    *reply4;        /* reply buffer (fourth part) */
 
92
        pgoff_t                 first;          /* first page in mapping to deal with */
 
93
        pgoff_t                 last;           /* last page in mapping to deal with */
 
94
        enum {                                  /* call state */
 
95
                AFS_CALL_REQUESTING,    /* request is being sent for outgoing call */
 
96
                AFS_CALL_AWAIT_REPLY,   /* awaiting reply to outgoing call */
 
97
                AFS_CALL_AWAIT_OP_ID,   /* awaiting op ID on incoming call */
 
98
                AFS_CALL_AWAIT_REQUEST, /* awaiting request data on incoming call */
 
99
                AFS_CALL_REPLYING,      /* replying to incoming call */
 
100
                AFS_CALL_AWAIT_ACK,     /* awaiting final ACK of incoming call */
 
101
                AFS_CALL_COMPLETE,      /* successfully completed */
 
102
                AFS_CALL_BUSY,          /* server was busy */
 
103
                AFS_CALL_ABORTED,       /* call was aborted */
 
104
                AFS_CALL_ERROR,         /* call failed due to error */
 
105
        }                       state;
 
106
        int                     error;          /* error code */
 
107
        unsigned                request_size;   /* size of request data */
 
108
        unsigned                reply_max;      /* maximum size of reply */
 
109
        unsigned                reply_size;     /* current size of reply */
 
110
        unsigned                first_offset;   /* offset into mapping[first] */
 
111
        unsigned                last_to;        /* amount of mapping[last] */
 
112
        unsigned short          offset;         /* offset into received data store */
 
113
        unsigned char           unmarshall;     /* unmarshalling phase */
 
114
        bool                    incoming;       /* T if incoming call */
 
115
        bool                    send_pages;     /* T if data from mapping should be sent */
 
116
        u16                     service_id;     /* RxRPC service ID to call */
 
117
        __be16                  port;           /* target UDP port */
 
118
        __be32                  operation_ID;   /* operation ID for an incoming call */
 
119
        u32                     count;          /* count for use in unmarshalling */
 
120
        __be32                  tmp;            /* place to extract temporary data */
 
121
        afs_dataversion_t       store_version;  /* updated version expected from store */
 
122
};
 
123
 
 
124
struct afs_call_type {
 
125
        const char *name;
 
126
 
 
127
        /* deliver request or reply data to an call
 
128
         * - returning an error will cause the call to be aborted
 
129
         */
 
130
        int (*deliver)(struct afs_call *call, struct sk_buff *skb,
 
131
                       bool last);
 
132
 
 
133
        /* map an abort code to an error number */
 
134
        int (*abort_to_error)(u32 abort_code);
 
135
 
 
136
        /* clean up a call */
 
137
        void (*destructor)(struct afs_call *call);
 
138
};
 
139
 
 
140
/*
 
141
 * record of an outstanding writeback on a vnode
 
142
 */
 
143
struct afs_writeback {
 
144
        struct list_head        link;           /* link in vnode->writebacks */
 
145
        struct work_struct      writer;         /* work item to perform the writeback */
 
146
        struct afs_vnode        *vnode;         /* vnode to which this write applies */
 
147
        struct key              *key;           /* owner of this write */
 
148
        wait_queue_head_t       waitq;          /* completion and ready wait queue */
 
149
        pgoff_t                 first;          /* first page in batch */
 
150
        pgoff_t                 point;          /* last page in current store op */
 
151
        pgoff_t                 last;           /* last page in batch (inclusive) */
 
152
        unsigned                offset_first;   /* offset into first page of start of write */
 
153
        unsigned                to_last;        /* offset into last page of end of write */
 
154
        int                     num_conflicts;  /* count of conflicting writes in list */
 
155
        int                     usage;
 
156
        bool                    conflicts;      /* T if has dependent conflicts */
 
157
        enum {
 
158
                AFS_WBACK_SYNCING,              /* synchronisation being performed */
 
159
                AFS_WBACK_PENDING,              /* write pending */
 
160
                AFS_WBACK_CONFLICTING,          /* conflicting writes posted */
 
161
                AFS_WBACK_WRITING,              /* writing back */
 
162
                AFS_WBACK_COMPLETE              /* the writeback record has been unlinked */
 
163
        } state __attribute__((packed));
 
164
};
 
165
 
 
166
/*
 
167
 * AFS superblock private data
 
168
 * - there's one superblock per volume
 
169
 */
 
170
struct afs_super_info {
 
171
        struct afs_volume       *volume;        /* volume record */
 
172
        char                    rwparent;       /* T if parent is R/W AFS volume */
 
173
};
 
174
 
 
175
static inline struct afs_super_info *AFS_FS_S(struct super_block *sb)
 
176
{
 
177
        return sb->s_fs_info;
 
178
}
 
179
 
 
180
extern struct file_system_type afs_fs_type;
 
181
 
 
182
/*
 
183
 * entry in the cached cell catalogue
 
184
 */
 
185
struct afs_cache_cell {
 
186
        char            name[AFS_MAXCELLNAME];  /* cell name (padded with NULs) */
 
187
        struct in_addr  vl_servers[15];         /* cached cell VL servers */
 
188
};
 
189
 
 
190
/*
 
191
 * AFS cell record
 
192
 */
 
193
struct afs_cell {
 
194
        atomic_t                usage;
 
195
        struct list_head        link;           /* main cell list link */
 
196
        struct key              *anonymous_key; /* anonymous user key for this cell */
 
197
        struct list_head        proc_link;      /* /proc cell list link */
 
198
        struct proc_dir_entry   *proc_dir;      /* /proc dir for this cell */
 
199
#ifdef CONFIG_AFS_FSCACHE
 
200
        struct fscache_cookie   *cache;         /* caching cookie */
 
201
#endif
 
202
 
 
203
        /* server record management */
 
204
        rwlock_t                servers_lock;   /* active server list lock */
 
205
        struct list_head        servers;        /* active server list */
 
206
 
 
207
        /* volume location record management */
 
208
        struct rw_semaphore     vl_sem;         /* volume management serialisation semaphore */
 
209
        struct list_head        vl_list;        /* cell's active VL record list */
 
210
        spinlock_t              vl_lock;        /* vl_list lock */
 
211
        unsigned short          vl_naddrs;      /* number of VL servers in addr list */
 
212
        unsigned short          vl_curr_svix;   /* current server index */
 
213
        struct in_addr          vl_addrs[AFS_CELL_MAX_ADDRS];   /* cell VL server addresses */
 
214
 
 
215
        char                    name[0];        /* cell name - must go last */
 
216
};
 
217
 
 
218
/*
 
219
 * entry in the cached volume location catalogue
 
220
 */
 
221
struct afs_cache_vlocation {
 
222
        /* volume name (lowercase, padded with NULs) */
 
223
        uint8_t                 name[AFS_MAXVOLNAME + 1];
 
224
 
 
225
        uint8_t                 nservers;       /* number of entries used in servers[] */
 
226
        uint8_t                 vidmask;        /* voltype mask for vid[] */
 
227
        uint8_t                 srvtmask[8];    /* voltype masks for servers[] */
 
228
#define AFS_VOL_VTM_RW  0x01 /* R/W version of the volume is available (on this server) */
 
229
#define AFS_VOL_VTM_RO  0x02 /* R/O version of the volume is available (on this server) */
 
230
#define AFS_VOL_VTM_BAK 0x04 /* backup version of the volume is available (on this server) */
 
231
 
 
232
        afs_volid_t             vid[3];         /* volume IDs for R/W, R/O and Bak volumes */
 
233
        struct in_addr          servers[8];     /* fileserver addresses */
 
234
        time_t                  rtime;          /* last retrieval time */
 
235
};
 
236
 
 
237
/*
 
238
 * volume -> vnode hash table entry
 
239
 */
 
240
struct afs_cache_vhash {
 
241
        afs_voltype_t           vtype;          /* which volume variation */
 
242
        uint8_t                 hash_bucket;    /* which hash bucket this represents */
 
243
} __attribute__((packed));
 
244
 
 
245
/*
 
246
 * AFS volume location record
 
247
 */
 
248
struct afs_vlocation {
 
249
        atomic_t                usage;
 
250
        time_t                  time_of_death;  /* time at which put reduced usage to 0 */
 
251
        struct list_head        link;           /* link in cell volume location list */
 
252
        struct list_head        grave;          /* link in master graveyard list */
 
253
        struct list_head        update;         /* link in master update list */
 
254
        struct afs_cell         *cell;          /* cell to which volume belongs */
 
255
#ifdef CONFIG_AFS_FSCACHE
 
256
        struct fscache_cookie   *cache;         /* caching cookie */
 
257
#endif
 
258
        struct afs_cache_vlocation vldb;        /* volume information DB record */
 
259
        struct afs_volume       *vols[3];       /* volume access record pointer (index by type) */
 
260
        wait_queue_head_t       waitq;          /* status change waitqueue */
 
261
        time_t                  update_at;      /* time at which record should be updated */
 
262
        spinlock_t              lock;           /* access lock */
 
263
        afs_vlocation_state_t   state;          /* volume location state */
 
264
        unsigned short          upd_rej_cnt;    /* ENOMEDIUM count during update */
 
265
        unsigned short          upd_busy_cnt;   /* EBUSY count during update */
 
266
        bool                    valid;          /* T if valid */
 
267
};
 
268
 
 
269
/*
 
270
 * AFS fileserver record
 
271
 */
 
272
struct afs_server {
 
273
        atomic_t                usage;
 
274
        time_t                  time_of_death;  /* time at which put reduced usage to 0 */
 
275
        struct in_addr          addr;           /* server address */
 
276
        struct afs_cell         *cell;          /* cell in which server resides */
 
277
        struct list_head        link;           /* link in cell's server list */
 
278
        struct list_head        grave;          /* link in master graveyard list */
 
279
        struct rb_node          master_rb;      /* link in master by-addr tree */
 
280
        struct rw_semaphore     sem;            /* access lock */
 
281
 
 
282
        /* file service access */
 
283
        struct rb_root          fs_vnodes;      /* vnodes backed by this server (ordered by FID) */
 
284
        unsigned long           fs_act_jif;     /* time at which last activity occurred */
 
285
        unsigned long           fs_dead_jif;    /* time at which no longer to be considered dead */
 
286
        spinlock_t              fs_lock;        /* access lock */
 
287
        int                     fs_state;       /* 0 or reason FS currently marked dead (-errno) */
 
288
 
 
289
        /* callback promise management */
 
290
        struct rb_root          cb_promises;    /* vnode expiration list (ordered earliest first) */
 
291
        struct delayed_work     cb_updater;     /* callback updater */
 
292
        struct delayed_work     cb_break_work;  /* collected break dispatcher */
 
293
        wait_queue_head_t       cb_break_waitq; /* space available in cb_break waitqueue */
 
294
        spinlock_t              cb_lock;        /* access lock */
 
295
        struct afs_callback     cb_break[64];   /* ring of callbacks awaiting breaking */
 
296
        atomic_t                cb_break_n;     /* number of pending breaks */
 
297
        u8                      cb_break_head;  /* head of callback breaking ring */
 
298
        u8                      cb_break_tail;  /* tail of callback breaking ring */
 
299
};
 
300
 
 
301
/*
 
302
 * AFS volume access record
 
303
 */
 
304
struct afs_volume {
 
305
        atomic_t                usage;
 
306
        struct afs_cell         *cell;          /* cell to which belongs (unrefd ptr) */
 
307
        struct afs_vlocation    *vlocation;     /* volume location */
 
308
#ifdef CONFIG_AFS_FSCACHE
 
309
        struct fscache_cookie   *cache;         /* caching cookie */
 
310
#endif
 
311
        afs_volid_t             vid;            /* volume ID */
 
312
        afs_voltype_t           type;           /* type of volume */
 
313
        char                    type_force;     /* force volume type (suppress R/O -> R/W) */
 
314
        unsigned short          nservers;       /* number of server slots filled */
 
315
        unsigned short          rjservers;      /* number of servers discarded due to -ENOMEDIUM */
 
316
        struct afs_server       *servers[8];    /* servers on which volume resides (ordered) */
 
317
        struct rw_semaphore     server_sem;     /* lock for accessing current server */
 
318
        struct backing_dev_info bdi;
 
319
};
 
320
 
 
321
/*
 
322
 * vnode catalogue entry
 
323
 */
 
324
struct afs_cache_vnode {
 
325
        afs_vnodeid_t           vnode_id;       /* vnode ID */
 
326
        unsigned                vnode_unique;   /* vnode ID uniquifier */
 
327
        afs_dataversion_t       data_version;   /* data version */
 
328
};
 
329
 
 
330
/*
 
331
 * AFS inode private data
 
332
 */
 
333
struct afs_vnode {
 
334
        struct inode            vfs_inode;      /* the VFS's inode record */
 
335
 
 
336
        struct afs_volume       *volume;        /* volume on which vnode resides */
 
337
        struct afs_server       *server;        /* server currently supplying this file */
 
338
        struct afs_fid          fid;            /* the file identifier for this inode */
 
339
        struct afs_file_status  status;         /* AFS status info for this file */
 
340
#ifdef CONFIG_AFS_FSCACHE
 
341
        struct fscache_cookie   *cache;         /* caching cookie */
 
342
#endif
 
343
        struct afs_permits      *permits;       /* cache of permits so far obtained */
 
344
        struct mutex            permits_lock;   /* lock for altering permits list */
 
345
        struct mutex            validate_lock;  /* lock for validating this vnode */
 
346
        wait_queue_head_t       update_waitq;   /* status fetch waitqueue */
 
347
        int                     update_cnt;     /* number of outstanding ops that will update the
 
348
                                                 * status */
 
349
        spinlock_t              writeback_lock; /* lock for writebacks */
 
350
        spinlock_t              lock;           /* waitqueue/flags lock */
 
351
        unsigned long           flags;
 
352
#define AFS_VNODE_CB_BROKEN     0               /* set if vnode's callback was broken */
 
353
#define AFS_VNODE_UNSET         1               /* set if vnode attributes not yet set */
 
354
#define AFS_VNODE_MODIFIED      2               /* set if vnode's data modified */
 
355
#define AFS_VNODE_ZAP_DATA      3               /* set if vnode's data should be invalidated */
 
356
#define AFS_VNODE_DELETED       4               /* set if vnode deleted on server */
 
357
#define AFS_VNODE_MOUNTPOINT    5               /* set if vnode is a mountpoint symlink */
 
358
#define AFS_VNODE_LOCKING       6               /* set if waiting for lock on vnode */
 
359
#define AFS_VNODE_READLOCKED    7               /* set if vnode is read-locked on the server */
 
360
#define AFS_VNODE_WRITELOCKED   8               /* set if vnode is write-locked on the server */
 
361
#define AFS_VNODE_UNLOCKING     9               /* set if vnode is being unlocked on the server */
 
362
#define AFS_VNODE_AUTOCELL      10              /* set if Vnode is an auto mount point */
 
363
#define AFS_VNODE_PSEUDODIR     11              /* set if Vnode is a pseudo directory */
 
364
 
 
365
        long                    acl_order;      /* ACL check count (callback break count) */
 
366
 
 
367
        struct list_head        writebacks;     /* alterations in pagecache that need writing */
 
368
        struct list_head        pending_locks;  /* locks waiting to be granted */
 
369
        struct list_head        granted_locks;  /* locks granted on this file */
 
370
        struct delayed_work     lock_work;      /* work to be done in locking */
 
371
        struct key              *unlock_key;    /* key to be used in unlocking */
 
372
 
 
373
        /* outstanding callback notification on this file */
 
374
        struct rb_node          server_rb;      /* link in server->fs_vnodes */
 
375
        struct rb_node          cb_promise;     /* link in server->cb_promises */
 
376
        struct work_struct      cb_broken_work; /* work to be done on callback break */
 
377
        time_t                  cb_expires;     /* time at which callback expires */
 
378
        time_t                  cb_expires_at;  /* time used to order cb_promise */
 
379
        unsigned                cb_version;     /* callback version */
 
380
        unsigned                cb_expiry;      /* callback expiry time */
 
381
        afs_callback_type_t     cb_type;        /* type of callback */
 
382
        bool                    cb_promised;    /* true if promise still holds */
 
383
};
 
384
 
 
385
/*
 
386
 * cached security record for one user's attempt to access a vnode
 
387
 */
 
388
struct afs_permit {
 
389
        struct key              *key;           /* RxRPC ticket holding a security context */
 
390
        afs_access_t            access_mask;    /* access mask for this key */
 
391
};
 
392
 
 
393
/*
 
394
 * cache of security records from attempts to access a vnode
 
395
 */
 
396
struct afs_permits {
 
397
        struct rcu_head         rcu;            /* disposal procedure */
 
398
        int                     count;          /* number of records */
 
399
        struct afs_permit       permits[0];     /* the permits so far examined */
 
400
};
 
401
 
 
402
/*
 
403
 * record of one of a system's set of network interfaces
 
404
 */
 
405
struct afs_interface {
 
406
        struct in_addr  address;        /* IPv4 address bound to interface */
 
407
        struct in_addr  netmask;        /* netmask applied to address */
 
408
        unsigned        mtu;            /* MTU of interface */
 
409
};
 
410
 
 
411
/*
 
412
 * UUID definition [internet draft]
 
413
 * - the timestamp is a 60-bit value, split 32/16/12, and goes in 100ns
 
414
 *   increments since midnight 15th October 1582
 
415
 *   - add AFS_UUID_TO_UNIX_TIME to convert unix time in 100ns units to UUID
 
416
 *     time
 
417
 * - the clock sequence is a 14-bit counter to avoid duplicate times
 
418
 */
 
419
struct afs_uuid {
 
420
        u32             time_low;                       /* low part of timestamp */
 
421
        u16             time_mid;                       /* mid part of timestamp */
 
422
        u16             time_hi_and_version;            /* high part of timestamp and version  */
 
423
#define AFS_UUID_TO_UNIX_TIME   0x01b21dd213814000ULL
 
424
#define AFS_UUID_TIMEHI_MASK    0x0fff
 
425
#define AFS_UUID_VERSION_TIME   0x1000  /* time-based UUID */
 
426
#define AFS_UUID_VERSION_NAME   0x3000  /* name-based UUID */
 
427
#define AFS_UUID_VERSION_RANDOM 0x4000  /* (pseudo-)random generated UUID */
 
428
        u8              clock_seq_hi_and_reserved;      /* clock seq hi and variant */
 
429
#define AFS_UUID_CLOCKHI_MASK   0x3f
 
430
#define AFS_UUID_VARIANT_STD    0x80
 
431
        u8              clock_seq_low;                  /* clock seq low */
 
432
        u8              node[6];                        /* spatially unique node ID (MAC addr) */
 
433
};
 
434
 
 
435
/*****************************************************************************/
 
436
/*
 
437
 * cache.c
 
438
 */
 
439
#ifdef CONFIG_AFS_FSCACHE
 
440
extern struct fscache_netfs afs_cache_netfs;
 
441
extern struct fscache_cookie_def afs_cell_cache_index_def;
 
442
extern struct fscache_cookie_def afs_vlocation_cache_index_def;
 
443
extern struct fscache_cookie_def afs_volume_cache_index_def;
 
444
extern struct fscache_cookie_def afs_vnode_cache_index_def;
 
445
#else
 
446
#define afs_cell_cache_index_def        (*(struct fscache_cookie_def *) NULL)
 
447
#define afs_vlocation_cache_index_def   (*(struct fscache_cookie_def *) NULL)
 
448
#define afs_volume_cache_index_def      (*(struct fscache_cookie_def *) NULL)
 
449
#define afs_vnode_cache_index_def       (*(struct fscache_cookie_def *) NULL)
 
450
#endif
 
451
 
 
452
/*
 
453
 * callback.c
 
454
 */
 
455
extern void afs_init_callback_state(struct afs_server *);
 
456
extern void afs_broken_callback_work(struct work_struct *);
 
457
extern void afs_break_callbacks(struct afs_server *, size_t,
 
458
                                struct afs_callback[]);
 
459
extern void afs_discard_callback_on_delete(struct afs_vnode *);
 
460
extern void afs_give_up_callback(struct afs_vnode *);
 
461
extern void afs_dispatch_give_up_callbacks(struct work_struct *);
 
462
extern void afs_flush_callback_breaks(struct afs_server *);
 
463
extern int __init afs_callback_update_init(void);
 
464
extern void afs_callback_update_kill(void);
 
465
 
 
466
/*
 
467
 * cell.c
 
468
 */
 
469
extern struct rw_semaphore afs_proc_cells_sem;
 
470
extern struct list_head afs_proc_cells;
 
471
 
 
472
#define afs_get_cell(C) do { atomic_inc(&(C)->usage); } while(0)
 
473
extern int afs_cell_init(char *);
 
474
extern struct afs_cell *afs_cell_create(const char *, unsigned, char *, bool);
 
475
extern struct afs_cell *afs_cell_lookup(const char *, unsigned, bool);
 
476
extern struct afs_cell *afs_grab_cell(struct afs_cell *);
 
477
extern void afs_put_cell(struct afs_cell *);
 
478
extern void afs_cell_purge(void);
 
479
 
 
480
/*
 
481
 * cmservice.c
 
482
 */
 
483
extern bool afs_cm_incoming_call(struct afs_call *);
 
484
 
 
485
/*
 
486
 * dir.c
 
487
 */
 
488
extern const struct inode_operations afs_dir_inode_operations;
 
489
extern const struct dentry_operations afs_fs_dentry_operations;
 
490
extern const struct file_operations afs_dir_file_operations;
 
491
 
 
492
/*
 
493
 * file.c
 
494
 */
 
495
extern const struct address_space_operations afs_fs_aops;
 
496
extern const struct inode_operations afs_file_inode_operations;
 
497
extern const struct file_operations afs_file_operations;
 
498
 
 
499
extern int afs_open(struct inode *, struct file *);
 
500
extern int afs_release(struct inode *, struct file *);
 
501
extern int afs_page_filler(void *, struct page *);
 
502
 
 
503
/*
 
504
 * flock.c
 
505
 */
 
506
extern void __exit afs_kill_lock_manager(void);
 
507
extern void afs_lock_work(struct work_struct *);
 
508
extern void afs_lock_may_be_available(struct afs_vnode *);
 
509
extern int afs_lock(struct file *, int, struct file_lock *);
 
510
extern int afs_flock(struct file *, int, struct file_lock *);
 
511
 
 
512
/*
 
513
 * fsclient.c
 
514
 */
 
515
extern int afs_fs_fetch_file_status(struct afs_server *, struct key *,
 
516
                                    struct afs_vnode *, struct afs_volsync *,
 
517
                                    const struct afs_wait_mode *);
 
518
extern int afs_fs_give_up_callbacks(struct afs_server *,
 
519
                                    const struct afs_wait_mode *);
 
520
extern int afs_fs_fetch_data(struct afs_server *, struct key *,
 
521
                             struct afs_vnode *, off_t, size_t, struct page *,
 
522
                             const struct afs_wait_mode *);
 
523
extern int afs_fs_create(struct afs_server *, struct key *,
 
524
                         struct afs_vnode *, const char *, umode_t,
 
525
                         struct afs_fid *, struct afs_file_status *,
 
526
                         struct afs_callback *,
 
527
                         const struct afs_wait_mode *);
 
528
extern int afs_fs_remove(struct afs_server *, struct key *,
 
529
                         struct afs_vnode *, const char *, bool,
 
530
                         const struct afs_wait_mode *);
 
531
extern int afs_fs_link(struct afs_server *, struct key *, struct afs_vnode *,
 
532
                       struct afs_vnode *, const char *,
 
533
                       const struct afs_wait_mode *);
 
534
extern int afs_fs_symlink(struct afs_server *, struct key *,
 
535
                          struct afs_vnode *, const char *, const char *,
 
536
                          struct afs_fid *, struct afs_file_status *,
 
537
                          const struct afs_wait_mode *);
 
538
extern int afs_fs_rename(struct afs_server *, struct key *,
 
539
                         struct afs_vnode *, const char *,
 
540
                         struct afs_vnode *, const char *,
 
541
                         const struct afs_wait_mode *);
 
542
extern int afs_fs_store_data(struct afs_server *, struct afs_writeback *,
 
543
                             pgoff_t, pgoff_t, unsigned, unsigned,
 
544
                             const struct afs_wait_mode *);
 
545
extern int afs_fs_setattr(struct afs_server *, struct key *,
 
546
                          struct afs_vnode *, struct iattr *,
 
547
                          const struct afs_wait_mode *);
 
548
extern int afs_fs_get_volume_status(struct afs_server *, struct key *,
 
549
                                    struct afs_vnode *,
 
550
                                    struct afs_volume_status *,
 
551
                                    const struct afs_wait_mode *);
 
552
extern int afs_fs_set_lock(struct afs_server *, struct key *,
 
553
                           struct afs_vnode *, afs_lock_type_t,
 
554
                           const struct afs_wait_mode *);
 
555
extern int afs_fs_extend_lock(struct afs_server *, struct key *,
 
556
                              struct afs_vnode *,
 
557
                              const struct afs_wait_mode *);
 
558
extern int afs_fs_release_lock(struct afs_server *, struct key *,
 
559
                               struct afs_vnode *,
 
560
                               const struct afs_wait_mode *);
 
561
 
 
562
/*
 
563
 * inode.c
 
564
 */
 
565
extern struct inode *afs_iget_autocell(struct inode *, const char *, int,
 
566
                                       struct key *);
 
567
extern struct inode *afs_iget(struct super_block *, struct key *,
 
568
                              struct afs_fid *, struct afs_file_status *,
 
569
                              struct afs_callback *);
 
570
extern void afs_zap_data(struct afs_vnode *);
 
571
extern int afs_validate(struct afs_vnode *, struct key *);
 
572
extern int afs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 
573
extern int afs_setattr(struct dentry *, struct iattr *);
 
574
extern void afs_evict_inode(struct inode *);
 
575
extern int afs_drop_inode(struct inode *);
 
576
 
 
577
/*
 
578
 * main.c
 
579
 */
 
580
extern struct workqueue_struct *afs_wq;
 
581
extern struct afs_uuid afs_uuid;
 
582
 
 
583
/*
 
584
 * misc.c
 
585
 */
 
586
extern int afs_abort_to_error(u32);
 
587
 
 
588
/*
 
589
 * mntpt.c
 
590
 */
 
591
extern const struct inode_operations afs_mntpt_inode_operations;
 
592
extern const struct inode_operations afs_autocell_inode_operations;
 
593
extern const struct file_operations afs_mntpt_file_operations;
 
594
 
 
595
extern struct vfsmount *afs_d_automount(struct path *);
 
596
extern int afs_mntpt_check_symlink(struct afs_vnode *, struct key *);
 
597
extern void afs_mntpt_kill_timer(void);
 
598
 
 
599
/*
 
600
 * proc.c
 
601
 */
 
602
extern int afs_proc_init(void);
 
603
extern void afs_proc_cleanup(void);
 
604
extern int afs_proc_cell_setup(struct afs_cell *);
 
605
extern void afs_proc_cell_remove(struct afs_cell *);
 
606
 
 
607
/*
 
608
 * rxrpc.c
 
609
 */
 
610
extern int afs_open_socket(void);
 
611
extern void afs_close_socket(void);
 
612
extern int afs_make_call(struct in_addr *, struct afs_call *, gfp_t,
 
613
                         const struct afs_wait_mode *);
 
614
extern struct afs_call *afs_alloc_flat_call(const struct afs_call_type *,
 
615
                                            size_t, size_t);
 
616
extern void afs_flat_call_destructor(struct afs_call *);
 
617
extern void afs_transfer_reply(struct afs_call *, struct sk_buff *);
 
618
extern void afs_send_empty_reply(struct afs_call *);
 
619
extern void afs_send_simple_reply(struct afs_call *, const void *, size_t);
 
620
extern int afs_extract_data(struct afs_call *, struct sk_buff *, bool, void *,
 
621
                            size_t);
 
622
 
 
623
/*
 
624
 * security.c
 
625
 */
 
626
extern void afs_clear_permits(struct afs_vnode *);
 
627
extern void afs_cache_permit(struct afs_vnode *, struct key *, long);
 
628
extern void afs_zap_permits(struct rcu_head *);
 
629
extern struct key *afs_request_key(struct afs_cell *);
 
630
extern int afs_permission(struct inode *, int);
 
631
 
 
632
/*
 
633
 * server.c
 
634
 */
 
635
extern spinlock_t afs_server_peer_lock;
 
636
 
 
637
#define afs_get_server(S)                                       \
 
638
do {                                                            \
 
639
        _debug("GET SERVER %d", atomic_read(&(S)->usage));      \
 
640
        atomic_inc(&(S)->usage);                                \
 
641
} while(0)
 
642
 
 
643
extern struct afs_server *afs_lookup_server(struct afs_cell *,
 
644
                                            const struct in_addr *);
 
645
extern struct afs_server *afs_find_server(const struct in_addr *);
 
646
extern void afs_put_server(struct afs_server *);
 
647
extern void __exit afs_purge_servers(void);
 
648
 
 
649
/*
 
650
 * super.c
 
651
 */
 
652
extern int afs_fs_init(void);
 
653
extern void afs_fs_exit(void);
 
654
 
 
655
/*
 
656
 * use-rtnetlink.c
 
657
 */
 
658
extern int afs_get_ipv4_interfaces(struct afs_interface *, size_t, bool);
 
659
extern int afs_get_MAC_address(u8 *, size_t);
 
660
 
 
661
/*
 
662
 * vlclient.c
 
663
 */
 
664
extern int afs_vl_get_entry_by_name(struct in_addr *, struct key *,
 
665
                                    const char *, struct afs_cache_vlocation *,
 
666
                                    const struct afs_wait_mode *);
 
667
extern int afs_vl_get_entry_by_id(struct in_addr *, struct key *,
 
668
                                  afs_volid_t, afs_voltype_t,
 
669
                                  struct afs_cache_vlocation *,
 
670
                                  const struct afs_wait_mode *);
 
671
 
 
672
/*
 
673
 * vlocation.c
 
674
 */
 
675
#define afs_get_vlocation(V) do { atomic_inc(&(V)->usage); } while(0)
 
676
 
 
677
extern int __init afs_vlocation_update_init(void);
 
678
extern struct afs_vlocation *afs_vlocation_lookup(struct afs_cell *,
 
679
                                                  struct key *,
 
680
                                                  const char *, size_t);
 
681
extern void afs_put_vlocation(struct afs_vlocation *);
 
682
extern void afs_vlocation_purge(void);
 
683
 
 
684
/*
 
685
 * vnode.c
 
686
 */
 
687
static inline struct afs_vnode *AFS_FS_I(struct inode *inode)
 
688
{
 
689
        return container_of(inode, struct afs_vnode, vfs_inode);
 
690
}
 
691
 
 
692
static inline struct inode *AFS_VNODE_TO_I(struct afs_vnode *vnode)
 
693
{
 
694
        return &vnode->vfs_inode;
 
695
}
 
696
 
 
697
extern void afs_vnode_finalise_status_update(struct afs_vnode *,
 
698
                                             struct afs_server *);
 
699
extern int afs_vnode_fetch_status(struct afs_vnode *, struct afs_vnode *,
 
700
                                  struct key *);
 
701
extern int afs_vnode_fetch_data(struct afs_vnode *, struct key *,
 
702
                                off_t, size_t, struct page *);
 
703
extern int afs_vnode_create(struct afs_vnode *, struct key *, const char *,
 
704
                            umode_t, struct afs_fid *, struct afs_file_status *,
 
705
                            struct afs_callback *, struct afs_server **);
 
706
extern int afs_vnode_remove(struct afs_vnode *, struct key *, const char *,
 
707
                            bool);
 
708
extern int afs_vnode_link(struct afs_vnode *, struct afs_vnode *, struct key *,
 
709
                          const char *);
 
710
extern int afs_vnode_symlink(struct afs_vnode *, struct key *, const char *,
 
711
                             const char *, struct afs_fid *,
 
712
                             struct afs_file_status *, struct afs_server **);
 
713
extern int afs_vnode_rename(struct afs_vnode *, struct afs_vnode *,
 
714
                            struct key *, const char *, const char *);
 
715
extern int afs_vnode_store_data(struct afs_writeback *, pgoff_t, pgoff_t,
 
716
                                unsigned, unsigned);
 
717
extern int afs_vnode_setattr(struct afs_vnode *, struct key *, struct iattr *);
 
718
extern int afs_vnode_get_volume_status(struct afs_vnode *, struct key *,
 
719
                                       struct afs_volume_status *);
 
720
extern int afs_vnode_set_lock(struct afs_vnode *, struct key *,
 
721
                              afs_lock_type_t);
 
722
extern int afs_vnode_extend_lock(struct afs_vnode *, struct key *);
 
723
extern int afs_vnode_release_lock(struct afs_vnode *, struct key *);
 
724
 
 
725
/*
 
726
 * volume.c
 
727
 */
 
728
#define afs_get_volume(V) do { atomic_inc(&(V)->usage); } while(0)
 
729
 
 
730
extern void afs_put_volume(struct afs_volume *);
 
731
extern struct afs_volume *afs_volume_lookup(struct afs_mount_params *);
 
732
extern struct afs_server *afs_volume_pick_fileserver(struct afs_vnode *);
 
733
extern int afs_volume_release_fileserver(struct afs_vnode *,
 
734
                                         struct afs_server *, int);
 
735
 
 
736
/*
 
737
 * write.c
 
738
 */
 
739
extern int afs_set_page_dirty(struct page *);
 
740
extern void afs_put_writeback(struct afs_writeback *);
 
741
extern int afs_write_begin(struct file *file, struct address_space *mapping,
 
742
                        loff_t pos, unsigned len, unsigned flags,
 
743
                        struct page **pagep, void **fsdata);
 
744
extern int afs_write_end(struct file *file, struct address_space *mapping,
 
745
                        loff_t pos, unsigned len, unsigned copied,
 
746
                        struct page *page, void *fsdata);
 
747
extern int afs_writepage(struct page *, struct writeback_control *);
 
748
extern int afs_writepages(struct address_space *, struct writeback_control *);
 
749
extern void afs_pages_written_back(struct afs_vnode *, struct afs_call *);
 
750
extern ssize_t afs_file_write(struct kiocb *, const struct iovec *,
 
751
                              unsigned long, loff_t);
 
752
extern int afs_writeback_all(struct afs_vnode *);
 
753
extern int afs_fsync(struct file *, loff_t, loff_t, int);
 
754
 
 
755
 
 
756
/*****************************************************************************/
 
757
/*
 
758
 * debug tracing
 
759
 */
 
760
extern unsigned afs_debug;
 
761
 
 
762
#define dbgprintk(FMT,...) \
 
763
        printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
 
764
 
 
765
#define kenter(FMT,...) dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
 
766
#define kleave(FMT,...) dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
 
767
#define kdebug(FMT,...) dbgprintk("    "FMT ,##__VA_ARGS__)
 
768
 
 
769
 
 
770
#if defined(__KDEBUG)
 
771
#define _enter(FMT,...) kenter(FMT,##__VA_ARGS__)
 
772
#define _leave(FMT,...) kleave(FMT,##__VA_ARGS__)
 
773
#define _debug(FMT,...) kdebug(FMT,##__VA_ARGS__)
 
774
 
 
775
#elif defined(CONFIG_AFS_DEBUG)
 
776
#define AFS_DEBUG_KENTER        0x01
 
777
#define AFS_DEBUG_KLEAVE        0x02
 
778
#define AFS_DEBUG_KDEBUG        0x04
 
779
 
 
780
#define _enter(FMT,...)                                 \
 
781
do {                                                    \
 
782
        if (unlikely(afs_debug & AFS_DEBUG_KENTER))     \
 
783
                kenter(FMT,##__VA_ARGS__);              \
 
784
} while (0)
 
785
 
 
786
#define _leave(FMT,...)                                 \
 
787
do {                                                    \
 
788
        if (unlikely(afs_debug & AFS_DEBUG_KLEAVE))     \
 
789
                kleave(FMT,##__VA_ARGS__);              \
 
790
} while (0)
 
791
 
 
792
#define _debug(FMT,...)                                 \
 
793
do {                                                    \
 
794
        if (unlikely(afs_debug & AFS_DEBUG_KDEBUG))     \
 
795
                kdebug(FMT,##__VA_ARGS__);              \
 
796
} while (0)
 
797
 
 
798
#else
 
799
#define _enter(FMT,...) no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
 
800
#define _leave(FMT,...) no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
 
801
#define _debug(FMT,...) no_printk("    "FMT ,##__VA_ARGS__)
 
802
#endif
 
803
 
 
804
/*
 
805
 * debug assertion checking
 
806
 */
 
807
#if 1 // defined(__KDEBUGALL)
 
808
 
 
809
#define ASSERT(X)                                               \
 
810
do {                                                            \
 
811
        if (unlikely(!(X))) {                                   \
 
812
                printk(KERN_ERR "\n");                          \
 
813
                printk(KERN_ERR "AFS: Assertion failed\n");     \
 
814
                BUG();                                          \
 
815
        }                                                       \
 
816
} while(0)
 
817
 
 
818
#define ASSERTCMP(X, OP, Y)                                             \
 
819
do {                                                                    \
 
820
        if (unlikely(!((X) OP (Y)))) {                                  \
 
821
                printk(KERN_ERR "\n");                                  \
 
822
                printk(KERN_ERR "AFS: Assertion failed\n");             \
 
823
                printk(KERN_ERR "%lu " #OP " %lu is false\n",           \
 
824
                       (unsigned long)(X), (unsigned long)(Y));         \
 
825
                printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n",       \
 
826
                       (unsigned long)(X), (unsigned long)(Y));         \
 
827
                BUG();                                                  \
 
828
        }                                                               \
 
829
} while(0)
 
830
 
 
831
#define ASSERTRANGE(L, OP1, N, OP2, H)                                  \
 
832
do {                                                                    \
 
833
        if (unlikely(!((L) OP1 (N)) || !((N) OP2 (H)))) {               \
 
834
                printk(KERN_ERR "\n");                                  \
 
835
                printk(KERN_ERR "AFS: Assertion failed\n");             \
 
836
                printk(KERN_ERR "%lu "#OP1" %lu "#OP2" %lu is false\n", \
 
837
                       (unsigned long)(L), (unsigned long)(N),          \
 
838
                       (unsigned long)(H));                             \
 
839
                printk(KERN_ERR "0x%lx "#OP1" 0x%lx "#OP2" 0x%lx is false\n", \
 
840
                       (unsigned long)(L), (unsigned long)(N),          \
 
841
                       (unsigned long)(H));                             \
 
842
                BUG();                                                  \
 
843
        }                                                               \
 
844
} while(0)
 
845
 
 
846
#define ASSERTIF(C, X)                                          \
 
847
do {                                                            \
 
848
        if (unlikely((C) && !(X))) {                            \
 
849
                printk(KERN_ERR "\n");                          \
 
850
                printk(KERN_ERR "AFS: Assertion failed\n");     \
 
851
                BUG();                                          \
 
852
        }                                                       \
 
853
} while(0)
 
854
 
 
855
#define ASSERTIFCMP(C, X, OP, Y)                                        \
 
856
do {                                                                    \
 
857
        if (unlikely((C) && !((X) OP (Y)))) {                           \
 
858
                printk(KERN_ERR "\n");                                  \
 
859
                printk(KERN_ERR "AFS: Assertion failed\n");             \
 
860
                printk(KERN_ERR "%lu " #OP " %lu is false\n",           \
 
861
                       (unsigned long)(X), (unsigned long)(Y));         \
 
862
                printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n",       \
 
863
                       (unsigned long)(X), (unsigned long)(Y));         \
 
864
                BUG();                                                  \
 
865
        }                                                               \
 
866
} while(0)
 
867
 
 
868
#else
 
869
 
 
870
#define ASSERT(X)                               \
 
871
do {                                            \
 
872
} while(0)
 
873
 
 
874
#define ASSERTCMP(X, OP, Y)                     \
 
875
do {                                            \
 
876
} while(0)
 
877
 
 
878
#define ASSERTRANGE(L, OP1, N, OP2, H)          \
 
879
do {                                            \
 
880
} while(0)
 
881
 
 
882
#define ASSERTIF(C, X)                          \
 
883
do {                                            \
 
884
} while(0)
 
885
 
 
886
#define ASSERTIFCMP(C, X, OP, Y)                \
 
887
do {                                            \
 
888
} while(0)
 
889
 
 
890
#endif /* __KDEBUGALL */