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