Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0-or-later */
0002 /* internal AFS stuff
0003  *
0004  * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
0005  * Written by David Howells (dhowells@redhat.com)
0006  */
0007 
0008 #include <linux/compiler.h>
0009 #include <linux/kernel.h>
0010 #include <linux/ktime.h>
0011 #include <linux/fs.h>
0012 #include <linux/pagemap.h>
0013 #include <linux/rxrpc.h>
0014 #include <linux/key.h>
0015 #include <linux/workqueue.h>
0016 #include <linux/sched.h>
0017 #include <linux/fscache.h>
0018 #include <linux/backing-dev.h>
0019 #include <linux/uuid.h>
0020 #include <linux/mm_types.h>
0021 #include <linux/dns_resolver.h>
0022 #include <net/net_namespace.h>
0023 #include <net/netns/generic.h>
0024 #include <net/sock.h>
0025 #include <net/af_rxrpc.h>
0026 
0027 #include "afs.h"
0028 #include "afs_vl.h"
0029 
0030 #define AFS_CELL_MAX_ADDRS 15
0031 
0032 struct pagevec;
0033 struct afs_call;
0034 struct afs_vnode;
0035 
0036 /*
0037  * Partial file-locking emulation mode.  (The problem being that AFS3 only
0038  * allows whole-file locks and no upgrading/downgrading).
0039  */
0040 enum afs_flock_mode {
0041     afs_flock_mode_unset,
0042     afs_flock_mode_local,   /* Local locking only */
0043     afs_flock_mode_openafs, /* Don't get server lock for a partial lock */
0044     afs_flock_mode_strict,  /* Always get a server lock for a partial lock */
0045     afs_flock_mode_write,   /* Get an exclusive server lock for a partial lock */
0046 };
0047 
0048 struct afs_fs_context {
0049     bool            force;      /* T to force cell type */
0050     bool            autocell;   /* T if set auto mount operation */
0051     bool            dyn_root;   /* T if dynamic root */
0052     bool            no_cell;    /* T if the source is "none" (for dynroot) */
0053     enum afs_flock_mode flock_mode; /* Partial file-locking emulation mode */
0054     afs_voltype_t       type;       /* type of volume requested */
0055     unsigned int        volnamesz;  /* size of volume name */
0056     const char      *volname;   /* name of volume to mount */
0057     struct afs_net      *net;       /* the AFS net namespace stuff */
0058     struct afs_cell     *cell;      /* cell in which to find volume */
0059     struct afs_volume   *volume;    /* volume record */
0060     struct key      *key;       /* key to use for secure mounting */
0061 };
0062 
0063 enum afs_call_state {
0064     AFS_CALL_CL_REQUESTING,     /* Client: Request is being sent */
0065     AFS_CALL_CL_AWAIT_REPLY,    /* Client: Awaiting reply */
0066     AFS_CALL_CL_PROC_REPLY,     /* Client: rxrpc call complete; processing reply */
0067     AFS_CALL_SV_AWAIT_OP_ID,    /* Server: Awaiting op ID */
0068     AFS_CALL_SV_AWAIT_REQUEST,  /* Server: Awaiting request data */
0069     AFS_CALL_SV_REPLYING,       /* Server: Replying */
0070     AFS_CALL_SV_AWAIT_ACK,      /* Server: Awaiting final ACK */
0071     AFS_CALL_COMPLETE,      /* Completed or failed */
0072 };
0073 
0074 /*
0075  * List of server addresses.
0076  */
0077 struct afs_addr_list {
0078     struct rcu_head     rcu;
0079     refcount_t      usage;
0080     u32         version;    /* Version */
0081     unsigned char       max_addrs;
0082     unsigned char       nr_addrs;
0083     unsigned char       preferred;  /* Preferred address */
0084     unsigned char       nr_ipv4;    /* Number of IPv4 addresses */
0085     enum dns_record_source  source:8;
0086     enum dns_lookup_status  status:8;
0087     unsigned long       failed;     /* Mask of addrs that failed locally/ICMP */
0088     unsigned long       responded;  /* Mask of addrs that responded */
0089     struct sockaddr_rxrpc   addrs[];
0090 #define AFS_MAX_ADDRESSES ((unsigned int)(sizeof(unsigned long) * 8))
0091 };
0092 
0093 /*
0094  * a record of an in-progress RxRPC call
0095  */
0096 struct afs_call {
0097     const struct afs_call_type *type;   /* type of call */
0098     struct afs_addr_list    *alist;     /* Address is alist[addr_ix] */
0099     wait_queue_head_t   waitq;      /* processes awaiting completion */
0100     struct work_struct  async_work; /* async I/O processor */
0101     struct work_struct  work;       /* actual work processor */
0102     struct rxrpc_call   *rxcall;    /* RxRPC call handle */
0103     struct key      *key;       /* security for this call */
0104     struct afs_net      *net;       /* The network namespace */
0105     struct afs_server   *server;    /* The fileserver record if fs op (pins ref) */
0106     struct afs_vlserver *vlserver;  /* The vlserver record if vl op */
0107     void            *request;   /* request data (first part) */
0108     size_t          iov_len;    /* Size of *iter to be used */
0109     struct iov_iter     def_iter;   /* Default buffer/data iterator */
0110     struct iov_iter     *write_iter;    /* Iterator defining write to be made */
0111     struct iov_iter     *iter;      /* Iterator currently in use */
0112     union { /* Convenience for ->def_iter */
0113         struct kvec kvec[1];
0114         struct bio_vec  bvec[1];
0115     };
0116     void            *buffer;    /* reply receive buffer */
0117     union {
0118         long            ret0;   /* Value to reply with instead of 0 */
0119         struct afs_addr_list    *ret_alist;
0120         struct afs_vldb_entry   *ret_vldb;
0121         char            *ret_str;
0122     };
0123     struct afs_operation    *op;
0124     unsigned int        server_index;
0125     refcount_t      ref;
0126     enum afs_call_state state;
0127     spinlock_t      state_lock;
0128     int         error;      /* error code */
0129     u32         abort_code; /* Remote abort ID or 0 */
0130     unsigned int        max_lifespan;   /* Maximum lifespan to set if not 0 */
0131     unsigned        request_size;   /* size of request data */
0132     unsigned        reply_max;  /* maximum size of reply */
0133     unsigned        count2;     /* count used in unmarshalling */
0134     unsigned char       unmarshall; /* unmarshalling phase */
0135     unsigned char       addr_ix;    /* Address in ->alist */
0136     bool            drop_ref;   /* T if need to drop ref for incoming call */
0137     bool            need_attention; /* T if RxRPC poked us */
0138     bool            async;      /* T if asynchronous */
0139     bool            upgrade;    /* T to request service upgrade */
0140     bool            intr;       /* T if interruptible */
0141     bool            unmarshalling_error; /* T if an unmarshalling error occurred */
0142     u16         service_id; /* Actual service ID (after upgrade) */
0143     unsigned int        debug_id;   /* Trace ID */
0144     u32         operation_ID;   /* operation ID for an incoming call */
0145     u32         count;      /* count for use in unmarshalling */
0146     union {                 /* place to extract temporary data */
0147         struct {
0148             __be32  tmp_u;
0149             __be32  tmp;
0150         } __attribute__((packed));
0151         __be64      tmp64;
0152     };
0153     ktime_t         issue_time; /* Time of issue of operation */
0154 };
0155 
0156 struct afs_call_type {
0157     const char *name;
0158     unsigned int op; /* Really enum afs_fs_operation */
0159 
0160     /* deliver request or reply data to an call
0161      * - returning an error will cause the call to be aborted
0162      */
0163     int (*deliver)(struct afs_call *call);
0164 
0165     /* clean up a call */
0166     void (*destructor)(struct afs_call *call);
0167 
0168     /* Work function */
0169     void (*work)(struct work_struct *work);
0170 
0171     /* Call done function (gets called immediately on success or failure) */
0172     void (*done)(struct afs_call *call);
0173 };
0174 
0175 /*
0176  * Key available for writeback on a file.
0177  */
0178 struct afs_wb_key {
0179     refcount_t      usage;
0180     struct key      *key;
0181     struct list_head    vnode_link; /* Link in vnode->wb_keys */
0182 };
0183 
0184 /*
0185  * AFS open file information record.  Pointed to by file->private_data.
0186  */
0187 struct afs_file {
0188     struct key      *key;       /* The key this file was opened with */
0189     struct afs_wb_key   *wb;        /* Writeback key record for this file */
0190 };
0191 
0192 static inline struct key *afs_file_key(struct file *file)
0193 {
0194     struct afs_file *af = file->private_data;
0195 
0196     return af->key;
0197 }
0198 
0199 /*
0200  * Record of an outstanding read operation on a vnode.
0201  */
0202 struct afs_read {
0203     loff_t          pos;        /* Where to start reading */
0204     loff_t          len;        /* How much we're asking for */
0205     loff_t          actual_len; /* How much we're actually getting */
0206     loff_t          file_size;  /* File size returned by server */
0207     struct key      *key;       /* The key to use to reissue the read */
0208     struct afs_vnode    *vnode;     /* The file being read into. */
0209     struct netfs_io_subrequest *subreq; /* Fscache helper read request this belongs to */
0210     afs_dataversion_t   data_version;   /* Version number returned by server */
0211     refcount_t      usage;
0212     unsigned int        call_debug_id;
0213     unsigned int        nr_pages;
0214     int         error;
0215     void (*done)(struct afs_read *);
0216     void (*cleanup)(struct afs_read *);
0217     struct iov_iter     *iter;      /* Iterator representing the buffer */
0218     struct iov_iter     def_iter;   /* Default iterator */
0219 };
0220 
0221 /*
0222  * AFS superblock private data
0223  * - there's one superblock per volume
0224  */
0225 struct afs_super_info {
0226     struct net      *net_ns;    /* Network namespace */
0227     struct afs_cell     *cell;      /* The cell in which the volume resides */
0228     struct afs_volume   *volume;    /* volume record */
0229     enum afs_flock_mode flock_mode:8;   /* File locking emulation mode */
0230     bool            dyn_root;   /* True if dynamic root */
0231 };
0232 
0233 static inline struct afs_super_info *AFS_FS_S(struct super_block *sb)
0234 {
0235     return sb->s_fs_info;
0236 }
0237 
0238 extern struct file_system_type afs_fs_type;
0239 
0240 /*
0241  * Set of substitutes for @sys.
0242  */
0243 struct afs_sysnames {
0244 #define AFS_NR_SYSNAME 16
0245     char            *subs[AFS_NR_SYSNAME];
0246     refcount_t      usage;
0247     unsigned short      nr;
0248     char            blank[1];
0249 };
0250 
0251 /*
0252  * AFS network namespace record.
0253  */
0254 struct afs_net {
0255     struct net      *net;       /* Backpointer to the owning net namespace */
0256     struct afs_uuid     uuid;
0257     bool            live;       /* F if this namespace is being removed */
0258 
0259     /* AF_RXRPC I/O stuff */
0260     struct socket       *socket;
0261     struct afs_call     *spare_incoming_call;
0262     struct work_struct  charge_preallocation_work;
0263     struct mutex        socket_mutex;
0264     atomic_t        nr_outstanding_calls;
0265     atomic_t        nr_superblocks;
0266 
0267     /* Cell database */
0268     struct rb_root      cells;
0269     struct afs_cell     *ws_cell;
0270     struct work_struct  cells_manager;
0271     struct timer_list   cells_timer;
0272     atomic_t        cells_outstanding;
0273     struct rw_semaphore cells_lock;
0274     struct mutex        cells_alias_lock;
0275 
0276     struct mutex        proc_cells_lock;
0277     struct hlist_head   proc_cells;
0278 
0279     /* Known servers.  Theoretically each fileserver can only be in one
0280      * cell, but in practice, people create aliases and subsets and there's
0281      * no easy way to distinguish them.
0282      */
0283     seqlock_t       fs_lock;    /* For fs_servers, fs_probe_*, fs_proc */
0284     struct rb_root      fs_servers; /* afs_server (by server UUID or address) */
0285     struct list_head    fs_probe_fast;  /* List of afs_server to probe at 30s intervals */
0286     struct list_head    fs_probe_slow;  /* List of afs_server to probe at 5m intervals */
0287     struct hlist_head   fs_proc;    /* procfs servers list */
0288 
0289     struct hlist_head   fs_addresses4;  /* afs_server (by lowest IPv4 addr) */
0290     struct hlist_head   fs_addresses6;  /* afs_server (by lowest IPv6 addr) */
0291     seqlock_t       fs_addr_lock;   /* For fs_addresses[46] */
0292 
0293     struct work_struct  fs_manager;
0294     struct timer_list   fs_timer;
0295 
0296     struct work_struct  fs_prober;
0297     struct timer_list   fs_probe_timer;
0298     atomic_t        servers_outstanding;
0299 
0300     /* File locking renewal management */
0301     struct mutex        lock_manager_mutex;
0302 
0303     /* Misc */
0304     struct super_block  *dynroot_sb;    /* Dynamic root mount superblock */
0305     struct proc_dir_entry   *proc_afs;  /* /proc/net/afs directory */
0306     struct afs_sysnames *sysnames;
0307     rwlock_t        sysnames_lock;
0308 
0309     /* Statistics counters */
0310     atomic_t        n_lookup;   /* Number of lookups done */
0311     atomic_t        n_reval;    /* Number of dentries needing revalidation */
0312     atomic_t        n_inval;    /* Number of invalidations by the server */
0313     atomic_t        n_relpg;    /* Number of invalidations by release_folio */
0314     atomic_t        n_read_dir; /* Number of directory pages read */
0315     atomic_t        n_dir_cr;   /* Number of directory entry creation edits */
0316     atomic_t        n_dir_rm;   /* Number of directory entry removal edits */
0317     atomic_t        n_stores;   /* Number of store ops */
0318     atomic_long_t       n_store_bytes;  /* Number of bytes stored */
0319     atomic_long_t       n_fetch_bytes;  /* Number of bytes fetched */
0320     atomic_t        n_fetches;  /* Number of data fetch ops */
0321 };
0322 
0323 extern const char afs_init_sysname[];
0324 
0325 enum afs_cell_state {
0326     AFS_CELL_UNSET,
0327     AFS_CELL_ACTIVATING,
0328     AFS_CELL_ACTIVE,
0329     AFS_CELL_DEACTIVATING,
0330     AFS_CELL_INACTIVE,
0331     AFS_CELL_FAILED,
0332     AFS_CELL_REMOVED,
0333 };
0334 
0335 /*
0336  * AFS cell record.
0337  *
0338  * This is a tricky concept to get right as it is possible to create aliases
0339  * simply by pointing AFSDB/SRV records for two names at the same set of VL
0340  * servers; it is also possible to do things like setting up two sets of VL
0341  * servers, one of which provides a superset of the volumes provided by the
0342  * other (for internal/external division, for example).
0343  *
0344  * Cells only exist in the sense that (a) a cell's name maps to a set of VL
0345  * servers and (b) a cell's name is used by the client to select the key to use
0346  * for authentication and encryption.  The cell name is not typically used in
0347  * the protocol.
0348  *
0349  * Two cells are determined to be aliases if they have an explicit alias (YFS
0350  * only), share any VL servers in common or have at least one volume in common.
0351  * "In common" means that the address list of the VL servers or the fileservers
0352  * share at least one endpoint.
0353  */
0354 struct afs_cell {
0355     union {
0356         struct rcu_head rcu;
0357         struct rb_node  net_node;   /* Node in net->cells */
0358     };
0359     struct afs_net      *net;
0360     struct afs_cell     *alias_of;  /* The cell this is an alias of */
0361     struct afs_volume   *root_volume;   /* The root.cell volume if there is one */
0362     struct key      *anonymous_key; /* anonymous user key for this cell */
0363     struct work_struct  manager;    /* Manager for init/deinit/dns */
0364     struct hlist_node   proc_link;  /* /proc cell list link */
0365     time64_t        dns_expiry; /* Time AFSDB/SRV record expires */
0366     time64_t        last_inactive;  /* Time of last drop of usage count */
0367     refcount_t      ref;        /* Struct refcount */
0368     atomic_t        active;     /* Active usage counter */
0369     unsigned long       flags;
0370 #define AFS_CELL_FL_NO_GC   0       /* The cell was added manually, don't auto-gc */
0371 #define AFS_CELL_FL_DO_LOOKUP   1       /* DNS lookup requested */
0372 #define AFS_CELL_FL_CHECK_ALIAS 2       /* Need to check for aliases */
0373     enum afs_cell_state state;
0374     short           error;
0375     enum dns_record_source  dns_source:8;   /* Latest source of data from lookup */
0376     enum dns_lookup_status  dns_status:8;   /* Latest status of data from lookup */
0377     unsigned int        dns_lookup_count; /* Counter of DNS lookups */
0378     unsigned int        debug_id;
0379 
0380     /* The volumes belonging to this cell */
0381     struct rb_root      volumes;    /* Tree of volumes on this server */
0382     struct hlist_head   proc_volumes;   /* procfs volume list */
0383     seqlock_t       volume_lock;    /* For volumes */
0384 
0385     /* Active fileserver interaction state. */
0386     struct rb_root      fs_servers; /* afs_server (by server UUID) */
0387     seqlock_t       fs_lock;    /* For fs_servers  */
0388     struct rw_semaphore fs_open_mmaps_lock;
0389     struct list_head    fs_open_mmaps;  /* List of vnodes that are mmapped */
0390     atomic_t        fs_s_break; /* Counter of CB.InitCallBackState messages */
0391 
0392     /* VL server list. */
0393     rwlock_t        vl_servers_lock; /* Lock on vl_servers */
0394     struct afs_vlserver_list __rcu *vl_servers;
0395 
0396     u8          name_len;   /* Length of name */
0397     char            *name;      /* Cell name, case-flattened and NUL-padded */
0398 };
0399 
0400 /*
0401  * Volume Location server record.
0402  */
0403 struct afs_vlserver {
0404     struct rcu_head     rcu;
0405     struct afs_addr_list    __rcu *addresses; /* List of addresses for this VL server */
0406     unsigned long       flags;
0407 #define AFS_VLSERVER_FL_PROBED  0       /* The VL server has been probed */
0408 #define AFS_VLSERVER_FL_PROBING 1       /* VL server is being probed */
0409 #define AFS_VLSERVER_FL_IS_YFS  2       /* Server is YFS not AFS */
0410 #define AFS_VLSERVER_FL_RESPONDING 3        /* VL server is responding */
0411     rwlock_t        lock;       /* Lock on addresses */
0412     refcount_t      ref;
0413     unsigned int        rtt;        /* Server's current RTT in uS */
0414 
0415     /* Probe state */
0416     wait_queue_head_t   probe_wq;
0417     atomic_t        probe_outstanding;
0418     spinlock_t      probe_lock;
0419     struct {
0420         unsigned int    rtt;        /* RTT in uS */
0421         u32     abort_code;
0422         short       error;
0423         unsigned short  flags;
0424 #define AFS_VLSERVER_PROBE_RESPONDED        0x01 /* At least once response (may be abort) */
0425 #define AFS_VLSERVER_PROBE_IS_YFS       0x02 /* The peer appears to be YFS */
0426 #define AFS_VLSERVER_PROBE_NOT_YFS      0x04 /* The peer appears not to be YFS */
0427 #define AFS_VLSERVER_PROBE_LOCAL_FAILURE    0x08 /* A local failure prevented a probe */
0428     } probe;
0429 
0430     u16         port;
0431     u16         name_len;   /* Length of name */
0432     char            name[];     /* Server name, case-flattened */
0433 };
0434 
0435 /*
0436  * Weighted list of Volume Location servers.
0437  */
0438 struct afs_vlserver_entry {
0439     u16         priority;   /* Preference (as SRV) */
0440     u16         weight;     /* Weight (as SRV) */
0441     enum dns_record_source  source:8;
0442     enum dns_lookup_status  status:8;
0443     struct afs_vlserver *server;
0444 };
0445 
0446 struct afs_vlserver_list {
0447     struct rcu_head     rcu;
0448     refcount_t      ref;
0449     u8          nr_servers;
0450     u8          index;      /* Server currently in use */
0451     u8          preferred;  /* Preferred server */
0452     enum dns_record_source  source:8;
0453     enum dns_lookup_status  status:8;
0454     rwlock_t        lock;
0455     struct afs_vlserver_entry servers[];
0456 };
0457 
0458 /*
0459  * Cached VLDB entry.
0460  *
0461  * This is pointed to by cell->vldb_entries, indexed by name.
0462  */
0463 struct afs_vldb_entry {
0464     afs_volid_t     vid[3];     /* Volume IDs for R/W, R/O and Bak volumes */
0465 
0466     unsigned long       flags;
0467 #define AFS_VLDB_HAS_RW     0       /* - R/W volume exists */
0468 #define AFS_VLDB_HAS_RO     1       /* - R/O volume exists */
0469 #define AFS_VLDB_HAS_BAK    2       /* - Backup volume exists */
0470 #define AFS_VLDB_QUERY_VALID    3       /* - Record is valid */
0471 #define AFS_VLDB_QUERY_ERROR    4       /* - VL server returned error */
0472 
0473     uuid_t          fs_server[AFS_NMAXNSERVERS];
0474     u32         addr_version[AFS_NMAXNSERVERS]; /* Registration change counters */
0475     u8          fs_mask[AFS_NMAXNSERVERS];
0476 #define AFS_VOL_VTM_RW  0x01 /* R/W version of the volume is available (on this server) */
0477 #define AFS_VOL_VTM_RO  0x02 /* R/O version of the volume is available (on this server) */
0478 #define AFS_VOL_VTM_BAK 0x04 /* backup version of the volume is available (on this server) */
0479     short           error;
0480     u8          nr_servers; /* Number of server records */
0481     u8          name_len;
0482     u8          name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
0483 };
0484 
0485 /*
0486  * Record of fileserver with which we're actively communicating.
0487  */
0488 struct afs_server {
0489     struct rcu_head     rcu;
0490     union {
0491         uuid_t      uuid;       /* Server ID */
0492         struct afs_uuid _uuid;
0493     };
0494 
0495     struct afs_addr_list    __rcu *addresses;
0496     struct afs_cell     *cell;      /* Cell to which belongs (pins ref) */
0497     struct rb_node      uuid_rb;    /* Link in net->fs_servers */
0498     struct afs_server __rcu *uuid_next; /* Next server with same UUID */
0499     struct afs_server   *uuid_prev; /* Previous server with same UUID */
0500     struct list_head    probe_link; /* Link in net->fs_probe_list */
0501     struct hlist_node   addr4_link; /* Link in net->fs_addresses4 */
0502     struct hlist_node   addr6_link; /* Link in net->fs_addresses6 */
0503     struct hlist_node   proc_link;  /* Link in net->fs_proc */
0504     struct work_struct  initcb_work;    /* Work for CB.InitCallBackState* */
0505     struct afs_server   *gc_next;   /* Next server in manager's list */
0506     time64_t        unuse_time; /* Time at which last unused */
0507     unsigned long       flags;
0508 #define AFS_SERVER_FL_RESPONDING 0      /* The server is responding */
0509 #define AFS_SERVER_FL_UPDATING  1
0510 #define AFS_SERVER_FL_NEEDS_UPDATE 2        /* Fileserver address list is out of date */
0511 #define AFS_SERVER_FL_NOT_READY 4       /* The record is not ready for use */
0512 #define AFS_SERVER_FL_NOT_FOUND 5       /* VL server says no such server */
0513 #define AFS_SERVER_FL_VL_FAIL   6       /* Failed to access VL server */
0514 #define AFS_SERVER_FL_MAY_HAVE_CB 8     /* May have callbacks on this fileserver */
0515 #define AFS_SERVER_FL_IS_YFS    16      /* Server is YFS not AFS */
0516 #define AFS_SERVER_FL_NO_IBULK  17      /* Fileserver doesn't support FS.InlineBulkStatus */
0517 #define AFS_SERVER_FL_NO_RM2    18      /* Fileserver doesn't support YFS.RemoveFile2 */
0518 #define AFS_SERVER_FL_HAS_FS64  19      /* Fileserver supports FS.{Fetch,Store}Data64 */
0519     refcount_t      ref;        /* Object refcount */
0520     atomic_t        active;     /* Active user count */
0521     u32         addr_version;   /* Address list version */
0522     unsigned int        rtt;        /* Server's current RTT in uS */
0523     unsigned int        debug_id;   /* Debugging ID for traces */
0524 
0525     /* file service access */
0526     rwlock_t        fs_lock;    /* access lock */
0527 
0528     /* callback promise management */
0529     unsigned        cb_s_break; /* Break-everything counter. */
0530 
0531     /* Probe state */
0532     unsigned long       probed_at;  /* Time last probe was dispatched (jiffies) */
0533     wait_queue_head_t   probe_wq;
0534     atomic_t        probe_outstanding;
0535     spinlock_t      probe_lock;
0536     struct {
0537         unsigned int    rtt;        /* RTT in uS */
0538         u32     abort_code;
0539         short       error;
0540         bool        responded:1;
0541         bool        is_yfs:1;
0542         bool        not_yfs:1;
0543         bool        local_failure:1;
0544     } probe;
0545 };
0546 
0547 /*
0548  * Replaceable volume server list.
0549  */
0550 struct afs_server_entry {
0551     struct afs_server   *server;
0552 };
0553 
0554 struct afs_server_list {
0555     afs_volid_t     vids[AFS_MAXTYPES]; /* Volume IDs */
0556     refcount_t      usage;
0557     unsigned char       nr_servers;
0558     unsigned char       preferred;  /* Preferred server */
0559     unsigned short      vnovol_mask;    /* Servers to be skipped due to VNOVOL */
0560     unsigned int        seq;        /* Set to ->servers_seq when installed */
0561     rwlock_t        lock;
0562     struct afs_server_entry servers[];
0563 };
0564 
0565 /*
0566  * Live AFS volume management.
0567  */
0568 struct afs_volume {
0569     union {
0570         struct rcu_head rcu;
0571         afs_volid_t vid;        /* volume ID */
0572     };
0573     refcount_t      ref;
0574     time64_t        update_at;  /* Time at which to next update */
0575     struct afs_cell     *cell;      /* Cell to which belongs (pins ref) */
0576     struct rb_node      cell_node;  /* Link in cell->volumes */
0577     struct hlist_node   proc_link;  /* Link in cell->proc_volumes */
0578     struct super_block __rcu *sb;       /* Superblock on which inodes reside */
0579     unsigned long       flags;
0580 #define AFS_VOLUME_NEEDS_UPDATE 0   /* - T if an update needs performing */
0581 #define AFS_VOLUME_UPDATING 1   /* - T if an update is in progress */
0582 #define AFS_VOLUME_WAIT     2   /* - T if users must wait for update */
0583 #define AFS_VOLUME_DELETED  3   /* - T if volume appears deleted */
0584 #define AFS_VOLUME_OFFLINE  4   /* - T if volume offline notice given */
0585 #define AFS_VOLUME_BUSY     5   /* - T if volume busy notice given */
0586 #define AFS_VOLUME_MAYBE_NO_IBULK 6 /* - T if some servers don't have InlineBulkStatus */
0587 #ifdef CONFIG_AFS_FSCACHE
0588     struct fscache_volume   *cache;     /* Caching cookie */
0589 #endif
0590     struct afs_server_list __rcu *servers;  /* List of servers on which volume resides */
0591     rwlock_t        servers_lock;   /* Lock for ->servers */
0592     unsigned int        servers_seq;    /* Incremented each time ->servers changes */
0593 
0594     unsigned        cb_v_break; /* Break-everything counter. */
0595     rwlock_t        cb_v_break_lock;
0596 
0597     afs_voltype_t       type;       /* type of volume */
0598     char            type_force; /* force volume type (suppress R/O -> R/W) */
0599     u8          name_len;
0600     u8          name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
0601 };
0602 
0603 enum afs_lock_state {
0604     AFS_VNODE_LOCK_NONE,        /* The vnode has no lock on the server */
0605     AFS_VNODE_LOCK_WAITING_FOR_CB,  /* We're waiting for the server to break the callback */
0606     AFS_VNODE_LOCK_SETTING,     /* We're asking the server for a lock */
0607     AFS_VNODE_LOCK_GRANTED,     /* We have a lock on the server */
0608     AFS_VNODE_LOCK_EXTENDING,   /* We're extending a lock on the server */
0609     AFS_VNODE_LOCK_NEED_UNLOCK, /* We need to unlock on the server */
0610     AFS_VNODE_LOCK_UNLOCKING,   /* We're telling the server to unlock */
0611     AFS_VNODE_LOCK_DELETED,     /* The vnode has been deleted whilst we have a lock */
0612 };
0613 
0614 /*
0615  * AFS inode private data.
0616  *
0617  * Note that afs_alloc_inode() *must* reset anything that could incorrectly
0618  * leak from one inode to another.
0619  */
0620 struct afs_vnode {
0621     struct netfs_inode  netfs;      /* Netfslib context and vfs inode */
0622     struct afs_volume   *volume;    /* volume on which vnode resides */
0623     struct afs_fid      fid;        /* the file identifier for this inode */
0624     struct afs_file_status  status;     /* AFS status info for this file */
0625     afs_dataversion_t   invalid_before; /* Child dentries are invalid before this */
0626     struct afs_permits __rcu *permit_cache; /* cache of permits so far obtained */
0627     struct mutex        io_lock;    /* Lock for serialising I/O on this mutex */
0628     struct rw_semaphore validate_lock;  /* lock for validating this vnode */
0629     struct rw_semaphore rmdir_lock; /* Lock for rmdir vs sillyrename */
0630     struct key      *silly_key; /* Silly rename key */
0631     spinlock_t      wb_lock;    /* lock for wb_keys */
0632     spinlock_t      lock;       /* waitqueue/flags lock */
0633     unsigned long       flags;
0634 #define AFS_VNODE_CB_PROMISED   0       /* Set if vnode has a callback promise */
0635 #define AFS_VNODE_UNSET     1       /* set if vnode attributes not yet set */
0636 #define AFS_VNODE_DIR_VALID 2       /* Set if dir contents are valid */
0637 #define AFS_VNODE_ZAP_DATA  3       /* set if vnode's data should be invalidated */
0638 #define AFS_VNODE_DELETED   4       /* set if vnode deleted on server */
0639 #define AFS_VNODE_MOUNTPOINT    5       /* set if vnode is a mountpoint symlink */
0640 #define AFS_VNODE_AUTOCELL  6       /* set if Vnode is an auto mount point */
0641 #define AFS_VNODE_PSEUDODIR 7       /* set if Vnode is a pseudo directory */
0642 #define AFS_VNODE_NEW_CONTENT   8       /* Set if file has new content (create/trunc-0) */
0643 #define AFS_VNODE_SILLY_DELETED 9       /* Set if file has been silly-deleted */
0644 #define AFS_VNODE_MODIFYING 10      /* Set if we're performing a modification op */
0645 
0646     struct list_head    wb_keys;    /* List of keys available for writeback */
0647     struct list_head    pending_locks;  /* locks waiting to be granted */
0648     struct list_head    granted_locks;  /* locks granted on this file */
0649     struct delayed_work lock_work;  /* work to be done in locking */
0650     struct key      *lock_key;  /* Key to be used in lock ops */
0651     ktime_t         locked_at;  /* Time at which lock obtained */
0652     enum afs_lock_state lock_state : 8;
0653     afs_lock_type_t     lock_type : 8;
0654 
0655     /* outstanding callback notification on this file */
0656     struct work_struct  cb_work;    /* Work for mmap'd files */
0657     struct list_head    cb_mmap_link;   /* Link in cell->fs_open_mmaps */
0658     void            *cb_server; /* Server with callback/filelock */
0659     atomic_t        cb_nr_mmap; /* Number of mmaps */
0660     unsigned int        cb_fs_s_break;  /* Mass server break counter (cell->fs_s_break) */
0661     unsigned int        cb_s_break; /* Mass break counter on ->server */
0662     unsigned int        cb_v_break; /* Mass break counter on ->volume */
0663     unsigned int        cb_break;   /* Break counter on vnode */
0664     seqlock_t       cb_lock;    /* Lock for ->cb_server, ->status, ->cb_*break */
0665 
0666     time64_t        cb_expires_at;  /* time at which callback expires */
0667 };
0668 
0669 static inline struct fscache_cookie *afs_vnode_cache(struct afs_vnode *vnode)
0670 {
0671 #ifdef CONFIG_AFS_FSCACHE
0672     return netfs_i_cookie(&vnode->netfs);
0673 #else
0674     return NULL;
0675 #endif
0676 }
0677 
0678 static inline void afs_vnode_set_cache(struct afs_vnode *vnode,
0679                        struct fscache_cookie *cookie)
0680 {
0681 #ifdef CONFIG_AFS_FSCACHE
0682     vnode->netfs.cache = cookie;
0683 #endif
0684 }
0685 
0686 /*
0687  * cached security record for one user's attempt to access a vnode
0688  */
0689 struct afs_permit {
0690     struct key      *key;       /* RxRPC ticket holding a security context */
0691     afs_access_t        access;     /* CallerAccess value for this key */
0692 };
0693 
0694 /*
0695  * Immutable cache of CallerAccess records from attempts to access vnodes.
0696  * These may be shared between multiple vnodes.
0697  */
0698 struct afs_permits {
0699     struct rcu_head     rcu;
0700     struct hlist_node   hash_node;  /* Link in hash */
0701     unsigned long       h;      /* Hash value for this permit list */
0702     refcount_t      usage;
0703     unsigned short      nr_permits; /* Number of records */
0704     bool            invalidated;    /* Invalidated due to key change */
0705     struct afs_permit   permits[];  /* List of permits sorted by key pointer */
0706 };
0707 
0708 /*
0709  * Error prioritisation and accumulation.
0710  */
0711 struct afs_error {
0712     short   error;          /* Accumulated error */
0713     bool    responded;      /* T if server responded */
0714 };
0715 
0716 /*
0717  * Cursor for iterating over a server's address list.
0718  */
0719 struct afs_addr_cursor {
0720     struct afs_addr_list    *alist;     /* Current address list (pins ref) */
0721     unsigned long       tried;      /* Tried addresses */
0722     signed char     index;      /* Current address */
0723     bool            responded;  /* T if the current address responded */
0724     unsigned short      nr_iterations;  /* Number of address iterations */
0725     short           error;
0726     u32         abort_code;
0727 };
0728 
0729 /*
0730  * Cursor for iterating over a set of volume location servers.
0731  */
0732 struct afs_vl_cursor {
0733     struct afs_addr_cursor  ac;
0734     struct afs_cell     *cell;      /* The cell we're querying */
0735     struct afs_vlserver_list *server_list;  /* Current server list (pins ref) */
0736     struct afs_vlserver *server;    /* Server on which this resides */
0737     struct key      *key;       /* Key for the server */
0738     unsigned long       untried;    /* Bitmask of untried servers */
0739     short           index;      /* Current server */
0740     short           error;
0741     unsigned short      flags;
0742 #define AFS_VL_CURSOR_STOP  0x0001      /* Set to cease iteration */
0743 #define AFS_VL_CURSOR_RETRY 0x0002      /* Set to do a retry */
0744 #define AFS_VL_CURSOR_RETRIED   0x0004      /* Set if started a retry */
0745     unsigned short      nr_iterations;  /* Number of server iterations */
0746 };
0747 
0748 /*
0749  * Fileserver operation methods.
0750  */
0751 struct afs_operation_ops {
0752     void (*issue_afs_rpc)(struct afs_operation *op);
0753     void (*issue_yfs_rpc)(struct afs_operation *op);
0754     void (*success)(struct afs_operation *op);
0755     void (*aborted)(struct afs_operation *op);
0756     void (*failed)(struct afs_operation *op);
0757     void (*edit_dir)(struct afs_operation *op);
0758     void (*put)(struct afs_operation *op);
0759 };
0760 
0761 struct afs_vnode_param {
0762     struct afs_vnode    *vnode;
0763     struct afs_fid      fid;        /* Fid to access */
0764     struct afs_status_cb    scb;        /* Returned status and callback promise */
0765     afs_dataversion_t   dv_before;  /* Data version before the call */
0766     unsigned int        cb_break_before; /* cb_break + cb_s_break before the call */
0767     u8          dv_delta;   /* Expected change in data version */
0768     bool            put_vnode:1;    /* T if we have a ref on the vnode */
0769     bool            need_io_lock:1; /* T if we need the I/O lock on this */
0770     bool            update_ctime:1; /* Need to update the ctime */
0771     bool            set_size:1; /* Must update i_size */
0772     bool            op_unlinked:1;  /* True if file was unlinked by op */
0773     bool            speculative:1;  /* T if speculative status fetch (no vnode lock) */
0774     bool            modification:1; /* Set if the content gets modified */
0775 };
0776 
0777 /*
0778  * Fileserver operation wrapper, handling server and address rotation
0779  * asynchronously.  May make simultaneous calls to multiple servers.
0780  */
0781 struct afs_operation {
0782     struct afs_net      *net;       /* Network namespace */
0783     struct key      *key;       /* Key for the cell */
0784     const struct afs_call_type *type;   /* Type of call done */
0785     const struct afs_operation_ops *ops;
0786 
0787     /* Parameters/results for the operation */
0788     struct afs_volume   *volume;    /* Volume being accessed */
0789     struct afs_vnode_param  file[2];
0790     struct afs_vnode_param  *more_files;
0791     struct afs_volsync  volsync;
0792     struct dentry       *dentry;    /* Dentry to be altered */
0793     struct dentry       *dentry_2;  /* Second dentry to be altered */
0794     struct timespec64   mtime;      /* Modification time to record */
0795     struct timespec64   ctime;      /* Change time to set */
0796     short           nr_files;   /* Number of entries in file[], more_files */
0797     short           error;
0798     unsigned int        debug_id;
0799 
0800     unsigned int        cb_v_break; /* Volume break counter before op */
0801     unsigned int        cb_s_break; /* Server break counter before op */
0802 
0803     union {
0804         struct {
0805             int which;      /* Which ->file[] to fetch for */
0806         } fetch_status;
0807         struct {
0808             int reason;     /* enum afs_edit_dir_reason */
0809             mode_t  mode;
0810             const char *symlink;
0811         } create;
0812         struct {
0813             bool    need_rehash;
0814         } unlink;
0815         struct {
0816             struct dentry *rehash;
0817             struct dentry *tmp;
0818             bool    new_negative;
0819         } rename;
0820         struct {
0821             struct afs_read *req;
0822         } fetch;
0823         struct {
0824             afs_lock_type_t type;
0825         } lock;
0826         struct {
0827             struct iov_iter *write_iter;
0828             loff_t  pos;
0829             loff_t  size;
0830             loff_t  i_size;
0831             bool    laundering; /* Laundering page, PG_writeback not set */
0832         } store;
0833         struct {
0834             struct iattr    *attr;
0835             loff_t      old_i_size;
0836         } setattr;
0837         struct afs_acl  *acl;
0838         struct yfs_acl  *yacl;
0839         struct {
0840             struct afs_volume_status vs;
0841             struct kstatfs      *buf;
0842         } volstatus;
0843     };
0844 
0845     /* Fileserver iteration state */
0846     struct afs_addr_cursor  ac;
0847     struct afs_server_list  *server_list;   /* Current server list (pins ref) */
0848     struct afs_server   *server;    /* Server we're using (ref pinned by server_list) */
0849     struct afs_call     *call;
0850     unsigned long       untried;    /* Bitmask of untried servers */
0851     short           index;      /* Current server */
0852     unsigned short      nr_iterations;  /* Number of server iterations */
0853 
0854     unsigned int        flags;
0855 #define AFS_OPERATION_STOP      0x0001  /* Set to cease iteration */
0856 #define AFS_OPERATION_VBUSY     0x0002  /* Set if seen VBUSY */
0857 #define AFS_OPERATION_VMOVED        0x0004  /* Set if seen VMOVED */
0858 #define AFS_OPERATION_VNOVOL        0x0008  /* Set if seen VNOVOL */
0859 #define AFS_OPERATION_CUR_ONLY      0x0010  /* Set if current server only (file lock held) */
0860 #define AFS_OPERATION_NO_VSLEEP     0x0020  /* Set to prevent sleep on VBUSY, VOFFLINE, ... */
0861 #define AFS_OPERATION_UNINTR        0x0040  /* Set if op is uninterruptible */
0862 #define AFS_OPERATION_DOWNGRADE     0x0080  /* Set to retry with downgraded opcode */
0863 #define AFS_OPERATION_LOCK_0        0x0100  /* Set if have io_lock on file[0] */
0864 #define AFS_OPERATION_LOCK_1        0x0200  /* Set if have io_lock on file[1] */
0865 #define AFS_OPERATION_TRIED_ALL     0x0400  /* Set if we've tried all the fileservers */
0866 #define AFS_OPERATION_RETRY_SERVER  0x0800  /* Set if we should retry the current server */
0867 #define AFS_OPERATION_DIR_CONFLICT  0x1000  /* Set if we detected a 3rd-party dir change */
0868 };
0869 
0870 /*
0871  * Cache auxiliary data.
0872  */
0873 struct afs_vnode_cache_aux {
0874     __be64          data_version;
0875 } __packed;
0876 
0877 static inline void afs_set_cache_aux(struct afs_vnode *vnode,
0878                      struct afs_vnode_cache_aux *aux)
0879 {
0880     aux->data_version = cpu_to_be64(vnode->status.data_version);
0881 }
0882 
0883 static inline void afs_invalidate_cache(struct afs_vnode *vnode, unsigned int flags)
0884 {
0885     struct afs_vnode_cache_aux aux;
0886 
0887     afs_set_cache_aux(vnode, &aux);
0888     fscache_invalidate(afs_vnode_cache(vnode), &aux,
0889                i_size_read(&vnode->netfs.inode), flags);
0890 }
0891 
0892 /*
0893  * We use folio->private to hold the amount of the folio that we've written to,
0894  * splitting the field into two parts.  However, we need to represent a range
0895  * 0...FOLIO_SIZE, so we reduce the resolution if the size of the folio
0896  * exceeds what we can encode.
0897  */
0898 #ifdef CONFIG_64BIT
0899 #define __AFS_FOLIO_PRIV_MASK       0x7fffffffUL
0900 #define __AFS_FOLIO_PRIV_SHIFT      32
0901 #define __AFS_FOLIO_PRIV_MMAPPED    0x80000000UL
0902 #else
0903 #define __AFS_FOLIO_PRIV_MASK       0x7fffUL
0904 #define __AFS_FOLIO_PRIV_SHIFT      16
0905 #define __AFS_FOLIO_PRIV_MMAPPED    0x8000UL
0906 #endif
0907 
0908 static inline unsigned int afs_folio_dirty_resolution(struct folio *folio)
0909 {
0910     int shift = folio_shift(folio) - (__AFS_FOLIO_PRIV_SHIFT - 1);
0911     return (shift > 0) ? shift : 0;
0912 }
0913 
0914 static inline size_t afs_folio_dirty_from(struct folio *folio, unsigned long priv)
0915 {
0916     unsigned long x = priv & __AFS_FOLIO_PRIV_MASK;
0917 
0918     /* The lower bound is inclusive */
0919     return x << afs_folio_dirty_resolution(folio);
0920 }
0921 
0922 static inline size_t afs_folio_dirty_to(struct folio *folio, unsigned long priv)
0923 {
0924     unsigned long x = (priv >> __AFS_FOLIO_PRIV_SHIFT) & __AFS_FOLIO_PRIV_MASK;
0925 
0926     /* The upper bound is immediately beyond the region */
0927     return (x + 1) << afs_folio_dirty_resolution(folio);
0928 }
0929 
0930 static inline unsigned long afs_folio_dirty(struct folio *folio, size_t from, size_t to)
0931 {
0932     unsigned int res = afs_folio_dirty_resolution(folio);
0933     from >>= res;
0934     to = (to - 1) >> res;
0935     return (to << __AFS_FOLIO_PRIV_SHIFT) | from;
0936 }
0937 
0938 static inline unsigned long afs_folio_dirty_mmapped(unsigned long priv)
0939 {
0940     return priv | __AFS_FOLIO_PRIV_MMAPPED;
0941 }
0942 
0943 static inline bool afs_is_folio_dirty_mmapped(unsigned long priv)
0944 {
0945     return priv & __AFS_FOLIO_PRIV_MMAPPED;
0946 }
0947 
0948 #include <trace/events/afs.h>
0949 
0950 /*****************************************************************************/
0951 /*
0952  * addr_list.c
0953  */
0954 static inline struct afs_addr_list *afs_get_addrlist(struct afs_addr_list *alist)
0955 {
0956     if (alist)
0957         refcount_inc(&alist->usage);
0958     return alist;
0959 }
0960 extern struct afs_addr_list *afs_alloc_addrlist(unsigned int,
0961                         unsigned short,
0962                         unsigned short);
0963 extern void afs_put_addrlist(struct afs_addr_list *);
0964 extern struct afs_vlserver_list *afs_parse_text_addrs(struct afs_net *,
0965                               const char *, size_t, char,
0966                               unsigned short, unsigned short);
0967 extern struct afs_vlserver_list *afs_dns_query(struct afs_cell *, time64_t *);
0968 extern bool afs_iterate_addresses(struct afs_addr_cursor *);
0969 extern int afs_end_cursor(struct afs_addr_cursor *);
0970 
0971 extern void afs_merge_fs_addr4(struct afs_addr_list *, __be32, u16);
0972 extern void afs_merge_fs_addr6(struct afs_addr_list *, __be32 *, u16);
0973 
0974 /*
0975  * cache.c
0976  */
0977 #ifdef CONFIG_AFS_FSCACHE
0978 extern struct fscache_netfs afs_cache_netfs;
0979 #endif
0980 
0981 /*
0982  * callback.c
0983  */
0984 extern void afs_invalidate_mmap_work(struct work_struct *);
0985 extern void afs_server_init_callback_work(struct work_struct *work);
0986 extern void afs_init_callback_state(struct afs_server *);
0987 extern void __afs_break_callback(struct afs_vnode *, enum afs_cb_break_reason);
0988 extern void afs_break_callback(struct afs_vnode *, enum afs_cb_break_reason);
0989 extern void afs_break_callbacks(struct afs_server *, size_t, struct afs_callback_break *);
0990 
0991 static inline unsigned int afs_calc_vnode_cb_break(struct afs_vnode *vnode)
0992 {
0993     return vnode->cb_break + vnode->cb_v_break;
0994 }
0995 
0996 static inline bool afs_cb_is_broken(unsigned int cb_break,
0997                     const struct afs_vnode *vnode)
0998 {
0999     return cb_break != (vnode->cb_break + vnode->volume->cb_v_break);
1000 }
1001 
1002 /*
1003  * cell.c
1004  */
1005 extern int afs_cell_init(struct afs_net *, const char *);
1006 extern struct afs_cell *afs_find_cell(struct afs_net *, const char *, unsigned,
1007                       enum afs_cell_trace);
1008 extern struct afs_cell *afs_lookup_cell(struct afs_net *, const char *, unsigned,
1009                     const char *, bool);
1010 extern struct afs_cell *afs_use_cell(struct afs_cell *, enum afs_cell_trace);
1011 extern void afs_unuse_cell(struct afs_net *, struct afs_cell *, enum afs_cell_trace);
1012 extern struct afs_cell *afs_get_cell(struct afs_cell *, enum afs_cell_trace);
1013 extern void afs_see_cell(struct afs_cell *, enum afs_cell_trace);
1014 extern void afs_put_cell(struct afs_cell *, enum afs_cell_trace);
1015 extern void afs_queue_cell(struct afs_cell *, enum afs_cell_trace);
1016 extern void afs_manage_cells(struct work_struct *);
1017 extern void afs_cells_timer(struct timer_list *);
1018 extern void __net_exit afs_cell_purge(struct afs_net *);
1019 
1020 /*
1021  * cmservice.c
1022  */
1023 extern bool afs_cm_incoming_call(struct afs_call *);
1024 
1025 /*
1026  * dir.c
1027  */
1028 extern const struct file_operations afs_dir_file_operations;
1029 extern const struct inode_operations afs_dir_inode_operations;
1030 extern const struct address_space_operations afs_dir_aops;
1031 extern const struct dentry_operations afs_fs_dentry_operations;
1032 
1033 extern void afs_d_release(struct dentry *);
1034 extern void afs_check_for_remote_deletion(struct afs_operation *);
1035 
1036 /*
1037  * dir_edit.c
1038  */
1039 extern void afs_edit_dir_add(struct afs_vnode *, struct qstr *, struct afs_fid *,
1040                  enum afs_edit_dir_reason);
1041 extern void afs_edit_dir_remove(struct afs_vnode *, struct qstr *, enum afs_edit_dir_reason);
1042 
1043 /*
1044  * dir_silly.c
1045  */
1046 extern int afs_sillyrename(struct afs_vnode *, struct afs_vnode *,
1047                struct dentry *, struct key *);
1048 extern int afs_silly_iput(struct dentry *, struct inode *);
1049 
1050 /*
1051  * dynroot.c
1052  */
1053 extern const struct inode_operations afs_dynroot_inode_operations;
1054 extern const struct dentry_operations afs_dynroot_dentry_operations;
1055 
1056 extern struct inode *afs_try_auto_mntpt(struct dentry *, struct inode *);
1057 extern int afs_dynroot_mkdir(struct afs_net *, struct afs_cell *);
1058 extern void afs_dynroot_rmdir(struct afs_net *, struct afs_cell *);
1059 extern int afs_dynroot_populate(struct super_block *);
1060 extern void afs_dynroot_depopulate(struct super_block *);
1061 
1062 /*
1063  * file.c
1064  */
1065 extern const struct address_space_operations afs_file_aops;
1066 extern const struct address_space_operations afs_symlink_aops;
1067 extern const struct inode_operations afs_file_inode_operations;
1068 extern const struct file_operations afs_file_operations;
1069 extern const struct netfs_request_ops afs_req_ops;
1070 
1071 extern int afs_cache_wb_key(struct afs_vnode *, struct afs_file *);
1072 extern void afs_put_wb_key(struct afs_wb_key *);
1073 extern int afs_open(struct inode *, struct file *);
1074 extern int afs_release(struct inode *, struct file *);
1075 extern int afs_fetch_data(struct afs_vnode *, struct afs_read *);
1076 extern struct afs_read *afs_alloc_read(gfp_t);
1077 extern void afs_put_read(struct afs_read *);
1078 extern int afs_write_inode(struct inode *, struct writeback_control *);
1079 
1080 static inline struct afs_read *afs_get_read(struct afs_read *req)
1081 {
1082     refcount_inc(&req->usage);
1083     return req;
1084 }
1085 
1086 /*
1087  * flock.c
1088  */
1089 extern struct workqueue_struct *afs_lock_manager;
1090 
1091 extern void afs_lock_op_done(struct afs_call *);
1092 extern void afs_lock_work(struct work_struct *);
1093 extern void afs_lock_may_be_available(struct afs_vnode *);
1094 extern int afs_lock(struct file *, int, struct file_lock *);
1095 extern int afs_flock(struct file *, int, struct file_lock *);
1096 
1097 /*
1098  * fsclient.c
1099  */
1100 extern void afs_fs_fetch_status(struct afs_operation *);
1101 extern void afs_fs_fetch_data(struct afs_operation *);
1102 extern void afs_fs_create_file(struct afs_operation *);
1103 extern void afs_fs_make_dir(struct afs_operation *);
1104 extern void afs_fs_remove_file(struct afs_operation *);
1105 extern void afs_fs_remove_dir(struct afs_operation *);
1106 extern void afs_fs_link(struct afs_operation *);
1107 extern void afs_fs_symlink(struct afs_operation *);
1108 extern void afs_fs_rename(struct afs_operation *);
1109 extern void afs_fs_store_data(struct afs_operation *);
1110 extern void afs_fs_setattr(struct afs_operation *);
1111 extern void afs_fs_get_volume_status(struct afs_operation *);
1112 extern void afs_fs_set_lock(struct afs_operation *);
1113 extern void afs_fs_extend_lock(struct afs_operation *);
1114 extern void afs_fs_release_lock(struct afs_operation *);
1115 extern int afs_fs_give_up_all_callbacks(struct afs_net *, struct afs_server *,
1116                     struct afs_addr_cursor *, struct key *);
1117 extern bool afs_fs_get_capabilities(struct afs_net *, struct afs_server *,
1118                     struct afs_addr_cursor *, struct key *);
1119 extern void afs_fs_inline_bulk_status(struct afs_operation *);
1120 
1121 struct afs_acl {
1122     u32 size;
1123     u8  data[];
1124 };
1125 
1126 extern void afs_fs_fetch_acl(struct afs_operation *);
1127 extern void afs_fs_store_acl(struct afs_operation *);
1128 
1129 /*
1130  * fs_operation.c
1131  */
1132 extern struct afs_operation *afs_alloc_operation(struct key *, struct afs_volume *);
1133 extern int afs_put_operation(struct afs_operation *);
1134 extern bool afs_begin_vnode_operation(struct afs_operation *);
1135 extern void afs_wait_for_operation(struct afs_operation *);
1136 extern int afs_do_sync_operation(struct afs_operation *);
1137 
1138 static inline void afs_op_nomem(struct afs_operation *op)
1139 {
1140     op->error = -ENOMEM;
1141 }
1142 
1143 static inline void afs_op_set_vnode(struct afs_operation *op, unsigned int n,
1144                     struct afs_vnode *vnode)
1145 {
1146     op->file[n].vnode = vnode;
1147     op->file[n].need_io_lock = true;
1148 }
1149 
1150 static inline void afs_op_set_fid(struct afs_operation *op, unsigned int n,
1151                   const struct afs_fid *fid)
1152 {
1153     op->file[n].fid = *fid;
1154 }
1155 
1156 /*
1157  * fs_probe.c
1158  */
1159 extern void afs_fileserver_probe_result(struct afs_call *);
1160 extern void afs_fs_probe_fileserver(struct afs_net *, struct afs_server *, struct key *, bool);
1161 extern int afs_wait_for_fs_probes(struct afs_server_list *, unsigned long);
1162 extern void afs_probe_fileserver(struct afs_net *, struct afs_server *);
1163 extern void afs_fs_probe_dispatcher(struct work_struct *);
1164 extern int afs_wait_for_one_fs_probe(struct afs_server *, bool);
1165 extern void afs_fs_probe_cleanup(struct afs_net *);
1166 
1167 /*
1168  * inode.c
1169  */
1170 extern const struct afs_operation_ops afs_fetch_status_operation;
1171 
1172 extern void afs_vnode_commit_status(struct afs_operation *, struct afs_vnode_param *);
1173 extern int afs_fetch_status(struct afs_vnode *, struct key *, bool, afs_access_t *);
1174 extern int afs_ilookup5_test_by_fid(struct inode *, void *);
1175 extern struct inode *afs_iget_pseudo_dir(struct super_block *, bool);
1176 extern struct inode *afs_iget(struct afs_operation *, struct afs_vnode_param *);
1177 extern struct inode *afs_root_iget(struct super_block *, struct key *);
1178 extern bool afs_check_validity(struct afs_vnode *);
1179 extern int afs_validate(struct afs_vnode *, struct key *);
1180 extern int afs_getattr(struct user_namespace *mnt_userns, const struct path *,
1181                struct kstat *, u32, unsigned int);
1182 extern int afs_setattr(struct user_namespace *mnt_userns, struct dentry *, struct iattr *);
1183 extern void afs_evict_inode(struct inode *);
1184 extern int afs_drop_inode(struct inode *);
1185 
1186 /*
1187  * main.c
1188  */
1189 extern struct workqueue_struct *afs_wq;
1190 extern int afs_net_id;
1191 
1192 static inline struct afs_net *afs_net(struct net *net)
1193 {
1194     return net_generic(net, afs_net_id);
1195 }
1196 
1197 static inline struct afs_net *afs_sb2net(struct super_block *sb)
1198 {
1199     return afs_net(AFS_FS_S(sb)->net_ns);
1200 }
1201 
1202 static inline struct afs_net *afs_d2net(struct dentry *dentry)
1203 {
1204     return afs_sb2net(dentry->d_sb);
1205 }
1206 
1207 static inline struct afs_net *afs_i2net(struct inode *inode)
1208 {
1209     return afs_sb2net(inode->i_sb);
1210 }
1211 
1212 static inline struct afs_net *afs_v2net(struct afs_vnode *vnode)
1213 {
1214     return afs_i2net(&vnode->netfs.inode);
1215 }
1216 
1217 static inline struct afs_net *afs_sock2net(struct sock *sk)
1218 {
1219     return net_generic(sock_net(sk), afs_net_id);
1220 }
1221 
1222 static inline void __afs_stat(atomic_t *s)
1223 {
1224     atomic_inc(s);
1225 }
1226 
1227 #define afs_stat_v(vnode, n) __afs_stat(&afs_v2net(vnode)->n)
1228 
1229 /*
1230  * misc.c
1231  */
1232 extern int afs_abort_to_error(u32);
1233 extern void afs_prioritise_error(struct afs_error *, int, u32);
1234 
1235 /*
1236  * mntpt.c
1237  */
1238 extern const struct inode_operations afs_mntpt_inode_operations;
1239 extern const struct inode_operations afs_autocell_inode_operations;
1240 extern const struct file_operations afs_mntpt_file_operations;
1241 
1242 extern struct vfsmount *afs_d_automount(struct path *);
1243 extern void afs_mntpt_kill_timer(void);
1244 
1245 /*
1246  * proc.c
1247  */
1248 #ifdef CONFIG_PROC_FS
1249 extern int __net_init afs_proc_init(struct afs_net *);
1250 extern void __net_exit afs_proc_cleanup(struct afs_net *);
1251 extern int afs_proc_cell_setup(struct afs_cell *);
1252 extern void afs_proc_cell_remove(struct afs_cell *);
1253 extern void afs_put_sysnames(struct afs_sysnames *);
1254 #else
1255 static inline int afs_proc_init(struct afs_net *net) { return 0; }
1256 static inline void afs_proc_cleanup(struct afs_net *net) {}
1257 static inline int afs_proc_cell_setup(struct afs_cell *cell) { return 0; }
1258 static inline void afs_proc_cell_remove(struct afs_cell *cell) {}
1259 static inline void afs_put_sysnames(struct afs_sysnames *sysnames) {}
1260 #endif
1261 
1262 /*
1263  * rotate.c
1264  */
1265 extern bool afs_select_fileserver(struct afs_operation *);
1266 extern void afs_dump_edestaddrreq(const struct afs_operation *);
1267 
1268 /*
1269  * rxrpc.c
1270  */
1271 extern struct workqueue_struct *afs_async_calls;
1272 
1273 extern int __net_init afs_open_socket(struct afs_net *);
1274 extern void __net_exit afs_close_socket(struct afs_net *);
1275 extern void afs_charge_preallocation(struct work_struct *);
1276 extern void afs_put_call(struct afs_call *);
1277 extern void afs_make_call(struct afs_addr_cursor *, struct afs_call *, gfp_t);
1278 extern long afs_wait_for_call_to_complete(struct afs_call *, struct afs_addr_cursor *);
1279 extern struct afs_call *afs_alloc_flat_call(struct afs_net *,
1280                         const struct afs_call_type *,
1281                         size_t, size_t);
1282 extern void afs_flat_call_destructor(struct afs_call *);
1283 extern void afs_send_empty_reply(struct afs_call *);
1284 extern void afs_send_simple_reply(struct afs_call *, const void *, size_t);
1285 extern int afs_extract_data(struct afs_call *, bool);
1286 extern int afs_protocol_error(struct afs_call *, enum afs_eproto_cause);
1287 
1288 static inline void afs_make_op_call(struct afs_operation *op, struct afs_call *call,
1289                     gfp_t gfp)
1290 {
1291     op->call = call;
1292     op->type = call->type;
1293     call->op = op;
1294     call->key = op->key;
1295     call->intr = !(op->flags & AFS_OPERATION_UNINTR);
1296     afs_make_call(&op->ac, call, gfp);
1297 }
1298 
1299 static inline void afs_extract_begin(struct afs_call *call, void *buf, size_t size)
1300 {
1301     call->iov_len = size;
1302     call->kvec[0].iov_base = buf;
1303     call->kvec[0].iov_len = size;
1304     iov_iter_kvec(&call->def_iter, READ, call->kvec, 1, size);
1305 }
1306 
1307 static inline void afs_extract_to_tmp(struct afs_call *call)
1308 {
1309     call->iov_len = sizeof(call->tmp);
1310     afs_extract_begin(call, &call->tmp, sizeof(call->tmp));
1311 }
1312 
1313 static inline void afs_extract_to_tmp64(struct afs_call *call)
1314 {
1315     call->iov_len = sizeof(call->tmp64);
1316     afs_extract_begin(call, &call->tmp64, sizeof(call->tmp64));
1317 }
1318 
1319 static inline void afs_extract_discard(struct afs_call *call, size_t size)
1320 {
1321     call->iov_len = size;
1322     iov_iter_discard(&call->def_iter, READ, size);
1323 }
1324 
1325 static inline void afs_extract_to_buf(struct afs_call *call, size_t size)
1326 {
1327     call->iov_len = size;
1328     afs_extract_begin(call, call->buffer, size);
1329 }
1330 
1331 static inline int afs_transfer_reply(struct afs_call *call)
1332 {
1333     return afs_extract_data(call, false);
1334 }
1335 
1336 static inline bool afs_check_call_state(struct afs_call *call,
1337                     enum afs_call_state state)
1338 {
1339     return READ_ONCE(call->state) == state;
1340 }
1341 
1342 static inline bool afs_set_call_state(struct afs_call *call,
1343                       enum afs_call_state from,
1344                       enum afs_call_state to)
1345 {
1346     bool ok = false;
1347 
1348     spin_lock_bh(&call->state_lock);
1349     if (call->state == from) {
1350         call->state = to;
1351         trace_afs_call_state(call, from, to, 0, 0);
1352         ok = true;
1353     }
1354     spin_unlock_bh(&call->state_lock);
1355     return ok;
1356 }
1357 
1358 static inline void afs_set_call_complete(struct afs_call *call,
1359                      int error, u32 remote_abort)
1360 {
1361     enum afs_call_state state;
1362     bool ok = false;
1363 
1364     spin_lock_bh(&call->state_lock);
1365     state = call->state;
1366     if (state != AFS_CALL_COMPLETE) {
1367         call->abort_code = remote_abort;
1368         call->error = error;
1369         call->state = AFS_CALL_COMPLETE;
1370         trace_afs_call_state(call, state, AFS_CALL_COMPLETE,
1371                      error, remote_abort);
1372         ok = true;
1373     }
1374     spin_unlock_bh(&call->state_lock);
1375     if (ok) {
1376         trace_afs_call_done(call);
1377 
1378         /* Asynchronous calls have two refs to release - one from the alloc and
1379          * one queued with the work item - and we can't just deallocate the
1380          * call because the work item may be queued again.
1381          */
1382         if (call->drop_ref)
1383             afs_put_call(call);
1384     }
1385 }
1386 
1387 /*
1388  * security.c
1389  */
1390 extern void afs_put_permits(struct afs_permits *);
1391 extern void afs_clear_permits(struct afs_vnode *);
1392 extern void afs_cache_permit(struct afs_vnode *, struct key *, unsigned int,
1393                  struct afs_status_cb *);
1394 extern void afs_zap_permits(struct rcu_head *);
1395 extern struct key *afs_request_key(struct afs_cell *);
1396 extern struct key *afs_request_key_rcu(struct afs_cell *);
1397 extern int afs_check_permit(struct afs_vnode *, struct key *, afs_access_t *);
1398 extern int afs_permission(struct user_namespace *, struct inode *, int);
1399 extern void __exit afs_clean_up_permit_cache(void);
1400 
1401 /*
1402  * server.c
1403  */
1404 extern spinlock_t afs_server_peer_lock;
1405 
1406 extern struct afs_server *afs_find_server(struct afs_net *,
1407                       const struct sockaddr_rxrpc *);
1408 extern struct afs_server *afs_find_server_by_uuid(struct afs_net *, const uuid_t *);
1409 extern struct afs_server *afs_lookup_server(struct afs_cell *, struct key *, const uuid_t *, u32);
1410 extern struct afs_server *afs_get_server(struct afs_server *, enum afs_server_trace);
1411 extern struct afs_server *afs_use_server(struct afs_server *, enum afs_server_trace);
1412 extern void afs_unuse_server(struct afs_net *, struct afs_server *, enum afs_server_trace);
1413 extern void afs_unuse_server_notime(struct afs_net *, struct afs_server *, enum afs_server_trace);
1414 extern void afs_put_server(struct afs_net *, struct afs_server *, enum afs_server_trace);
1415 extern void afs_manage_servers(struct work_struct *);
1416 extern void afs_servers_timer(struct timer_list *);
1417 extern void afs_fs_probe_timer(struct timer_list *);
1418 extern void __net_exit afs_purge_servers(struct afs_net *);
1419 extern bool afs_check_server_record(struct afs_operation *, struct afs_server *);
1420 
1421 static inline void afs_inc_servers_outstanding(struct afs_net *net)
1422 {
1423     atomic_inc(&net->servers_outstanding);
1424 }
1425 
1426 static inline void afs_dec_servers_outstanding(struct afs_net *net)
1427 {
1428     if (atomic_dec_and_test(&net->servers_outstanding))
1429         wake_up_var(&net->servers_outstanding);
1430 }
1431 
1432 static inline bool afs_is_probing_server(struct afs_server *server)
1433 {
1434     return list_empty(&server->probe_link);
1435 }
1436 
1437 /*
1438  * server_list.c
1439  */
1440 static inline struct afs_server_list *afs_get_serverlist(struct afs_server_list *slist)
1441 {
1442     refcount_inc(&slist->usage);
1443     return slist;
1444 }
1445 
1446 extern void afs_put_serverlist(struct afs_net *, struct afs_server_list *);
1447 extern struct afs_server_list *afs_alloc_server_list(struct afs_cell *, struct key *,
1448                              struct afs_vldb_entry *,
1449                              u8);
1450 extern bool afs_annotate_server_list(struct afs_server_list *, struct afs_server_list *);
1451 
1452 /*
1453  * super.c
1454  */
1455 extern int __init afs_fs_init(void);
1456 extern void afs_fs_exit(void);
1457 
1458 /*
1459  * vlclient.c
1460  */
1461 extern struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *,
1462                              const char *, int);
1463 extern struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *, const uuid_t *);
1464 extern struct afs_call *afs_vl_get_capabilities(struct afs_net *, struct afs_addr_cursor *,
1465                         struct key *, struct afs_vlserver *, unsigned int);
1466 extern struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *, const uuid_t *);
1467 extern char *afs_yfsvl_get_cell_name(struct afs_vl_cursor *);
1468 
1469 /*
1470  * vl_alias.c
1471  */
1472 extern int afs_cell_detect_alias(struct afs_cell *, struct key *);
1473 
1474 /*
1475  * vl_probe.c
1476  */
1477 extern void afs_vlserver_probe_result(struct afs_call *);
1478 extern int afs_send_vl_probes(struct afs_net *, struct key *, struct afs_vlserver_list *);
1479 extern int afs_wait_for_vl_probes(struct afs_vlserver_list *, unsigned long);
1480 
1481 /*
1482  * vl_rotate.c
1483  */
1484 extern bool afs_begin_vlserver_operation(struct afs_vl_cursor *,
1485                      struct afs_cell *, struct key *);
1486 extern bool afs_select_vlserver(struct afs_vl_cursor *);
1487 extern bool afs_select_current_vlserver(struct afs_vl_cursor *);
1488 extern int afs_end_vlserver_operation(struct afs_vl_cursor *);
1489 
1490 /*
1491  * vlserver_list.c
1492  */
1493 static inline struct afs_vlserver *afs_get_vlserver(struct afs_vlserver *vlserver)
1494 {
1495     refcount_inc(&vlserver->ref);
1496     return vlserver;
1497 }
1498 
1499 static inline struct afs_vlserver_list *afs_get_vlserverlist(struct afs_vlserver_list *vllist)
1500 {
1501     if (vllist)
1502         refcount_inc(&vllist->ref);
1503     return vllist;
1504 }
1505 
1506 extern struct afs_vlserver *afs_alloc_vlserver(const char *, size_t, unsigned short);
1507 extern void afs_put_vlserver(struct afs_net *, struct afs_vlserver *);
1508 extern struct afs_vlserver_list *afs_alloc_vlserver_list(unsigned int);
1509 extern void afs_put_vlserverlist(struct afs_net *, struct afs_vlserver_list *);
1510 extern struct afs_vlserver_list *afs_extract_vlserver_list(struct afs_cell *,
1511                                const void *, size_t);
1512 
1513 /*
1514  * volume.c
1515  */
1516 extern struct afs_volume *afs_create_volume(struct afs_fs_context *);
1517 extern int afs_activate_volume(struct afs_volume *);
1518 extern void afs_deactivate_volume(struct afs_volume *);
1519 extern struct afs_volume *afs_get_volume(struct afs_volume *, enum afs_volume_trace);
1520 extern void afs_put_volume(struct afs_net *, struct afs_volume *, enum afs_volume_trace);
1521 extern int afs_check_volume_status(struct afs_volume *, struct afs_operation *);
1522 
1523 /*
1524  * write.c
1525  */
1526 #ifdef CONFIG_AFS_FSCACHE
1527 bool afs_dirty_folio(struct address_space *, struct folio *);
1528 #else
1529 #define afs_dirty_folio filemap_dirty_folio
1530 #endif
1531 extern int afs_write_begin(struct file *file, struct address_space *mapping,
1532             loff_t pos, unsigned len,
1533             struct page **pagep, void **fsdata);
1534 extern int afs_write_end(struct file *file, struct address_space *mapping,
1535             loff_t pos, unsigned len, unsigned copied,
1536             struct page *page, void *fsdata);
1537 extern int afs_writepage(struct page *, struct writeback_control *);
1538 extern int afs_writepages(struct address_space *, struct writeback_control *);
1539 extern ssize_t afs_file_write(struct kiocb *, struct iov_iter *);
1540 extern int afs_fsync(struct file *, loff_t, loff_t, int);
1541 extern vm_fault_t afs_page_mkwrite(struct vm_fault *vmf);
1542 extern void afs_prune_wb_keys(struct afs_vnode *);
1543 int afs_launder_folio(struct folio *);
1544 
1545 /*
1546  * xattr.c
1547  */
1548 extern const struct xattr_handler *afs_xattr_handlers[];
1549 
1550 /*
1551  * yfsclient.c
1552  */
1553 extern void yfs_fs_fetch_data(struct afs_operation *);
1554 extern void yfs_fs_create_file(struct afs_operation *);
1555 extern void yfs_fs_make_dir(struct afs_operation *);
1556 extern void yfs_fs_remove_file2(struct afs_operation *);
1557 extern void yfs_fs_remove_file(struct afs_operation *);
1558 extern void yfs_fs_remove_dir(struct afs_operation *);
1559 extern void yfs_fs_link(struct afs_operation *);
1560 extern void yfs_fs_symlink(struct afs_operation *);
1561 extern void yfs_fs_rename(struct afs_operation *);
1562 extern void yfs_fs_store_data(struct afs_operation *);
1563 extern void yfs_fs_setattr(struct afs_operation *);
1564 extern void yfs_fs_get_volume_status(struct afs_operation *);
1565 extern void yfs_fs_set_lock(struct afs_operation *);
1566 extern void yfs_fs_extend_lock(struct afs_operation *);
1567 extern void yfs_fs_release_lock(struct afs_operation *);
1568 extern void yfs_fs_fetch_status(struct afs_operation *);
1569 extern void yfs_fs_inline_bulk_status(struct afs_operation *);
1570 
1571 struct yfs_acl {
1572     struct afs_acl  *acl;       /* Dir/file/symlink ACL */
1573     struct afs_acl  *vol_acl;   /* Whole volume ACL */
1574     u32     inherit_flag;   /* True if ACL is inherited from parent dir */
1575     u32     num_cleaned;    /* Number of ACEs removed due to subject removal */
1576     unsigned int    flags;
1577 #define YFS_ACL_WANT_ACL    0x01    /* Set if caller wants ->acl */
1578 #define YFS_ACL_WANT_VOL_ACL    0x02    /* Set if caller wants ->vol_acl */
1579 };
1580 
1581 extern void yfs_free_opaque_acl(struct yfs_acl *);
1582 extern void yfs_fs_fetch_opaque_acl(struct afs_operation *);
1583 extern void yfs_fs_store_opaque_acl2(struct afs_operation *);
1584 
1585 /*
1586  * Miscellaneous inline functions.
1587  */
1588 static inline struct afs_vnode *AFS_FS_I(struct inode *inode)
1589 {
1590     return container_of(inode, struct afs_vnode, netfs.inode);
1591 }
1592 
1593 static inline struct inode *AFS_VNODE_TO_I(struct afs_vnode *vnode)
1594 {
1595     return &vnode->netfs.inode;
1596 }
1597 
1598 /*
1599  * Note that a dentry got changed.  We need to set d_fsdata to the data version
1600  * number derived from the result of the operation.  It doesn't matter if
1601  * d_fsdata goes backwards as we'll just revalidate.
1602  */
1603 static inline void afs_update_dentry_version(struct afs_operation *op,
1604                          struct afs_vnode_param *dir_vp,
1605                          struct dentry *dentry)
1606 {
1607     if (!op->error)
1608         dentry->d_fsdata =
1609             (void *)(unsigned long)dir_vp->scb.status.data_version;
1610 }
1611 
1612 /*
1613  * Set the file size and block count.  Estimate the number of 512 bytes blocks
1614  * used, rounded up to nearest 1K for consistency with other AFS clients.
1615  */
1616 static inline void afs_set_i_size(struct afs_vnode *vnode, u64 size)
1617 {
1618     i_size_write(&vnode->netfs.inode, size);
1619     vnode->netfs.inode.i_blocks = ((size + 1023) >> 10) << 1;
1620 }
1621 
1622 /*
1623  * Check for a conflicting operation on a directory that we just unlinked from.
1624  * If someone managed to sneak a link or an unlink in on the file we just
1625  * unlinked, we won't be able to trust nlink on an AFS file (but not YFS).
1626  */
1627 static inline void afs_check_dir_conflict(struct afs_operation *op,
1628                       struct afs_vnode_param *dvp)
1629 {
1630     if (dvp->dv_before + dvp->dv_delta != dvp->scb.status.data_version)
1631         op->flags |= AFS_OPERATION_DIR_CONFLICT;
1632 }
1633 
1634 static inline int afs_io_error(struct afs_call *call, enum afs_io_error where)
1635 {
1636     trace_afs_io_error(call->debug_id, -EIO, where);
1637     return -EIO;
1638 }
1639 
1640 static inline int afs_bad(struct afs_vnode *vnode, enum afs_file_error where)
1641 {
1642     trace_afs_file_error(vnode, -EIO, where);
1643     return -EIO;
1644 }
1645 
1646 /*****************************************************************************/
1647 /*
1648  * debug tracing
1649  */
1650 extern unsigned afs_debug;
1651 
1652 #define dbgprintk(FMT,...) \
1653     printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
1654 
1655 #define kenter(FMT,...) dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1656 #define kleave(FMT,...) dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1657 #define kdebug(FMT,...) dbgprintk("    "FMT ,##__VA_ARGS__)
1658 
1659 
1660 #if defined(__KDEBUG)
1661 #define _enter(FMT,...) kenter(FMT,##__VA_ARGS__)
1662 #define _leave(FMT,...) kleave(FMT,##__VA_ARGS__)
1663 #define _debug(FMT,...) kdebug(FMT,##__VA_ARGS__)
1664 
1665 #elif defined(CONFIG_AFS_DEBUG)
1666 #define AFS_DEBUG_KENTER    0x01
1667 #define AFS_DEBUG_KLEAVE    0x02
1668 #define AFS_DEBUG_KDEBUG    0x04
1669 
1670 #define _enter(FMT,...)                 \
1671 do {                            \
1672     if (unlikely(afs_debug & AFS_DEBUG_KENTER)) \
1673         kenter(FMT,##__VA_ARGS__);      \
1674 } while (0)
1675 
1676 #define _leave(FMT,...)                 \
1677 do {                            \
1678     if (unlikely(afs_debug & AFS_DEBUG_KLEAVE)) \
1679         kleave(FMT,##__VA_ARGS__);      \
1680 } while (0)
1681 
1682 #define _debug(FMT,...)                 \
1683 do {                            \
1684     if (unlikely(afs_debug & AFS_DEBUG_KDEBUG)) \
1685         kdebug(FMT,##__VA_ARGS__);      \
1686 } while (0)
1687 
1688 #else
1689 #define _enter(FMT,...) no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1690 #define _leave(FMT,...) no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1691 #define _debug(FMT,...) no_printk("    "FMT ,##__VA_ARGS__)
1692 #endif
1693 
1694 /*
1695  * debug assertion checking
1696  */
1697 #if 1 // defined(__KDEBUGALL)
1698 
1699 #define ASSERT(X)                       \
1700 do {                                \
1701     if (unlikely(!(X))) {                   \
1702         printk(KERN_ERR "\n");              \
1703         printk(KERN_ERR "AFS: Assertion failed\n"); \
1704         BUG();                      \
1705     }                           \
1706 } while(0)
1707 
1708 #define ASSERTCMP(X, OP, Y)                     \
1709 do {                                    \
1710     if (unlikely(!((X) OP (Y)))) {                  \
1711         printk(KERN_ERR "\n");                  \
1712         printk(KERN_ERR "AFS: Assertion failed\n");     \
1713         printk(KERN_ERR "%lu " #OP " %lu is false\n",       \
1714                (unsigned long)(X), (unsigned long)(Y));     \
1715         printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n",   \
1716                (unsigned long)(X), (unsigned long)(Y));     \
1717         BUG();                          \
1718     }                               \
1719 } while(0)
1720 
1721 #define ASSERTRANGE(L, OP1, N, OP2, H)                  \
1722 do {                                    \
1723     if (unlikely(!((L) OP1 (N)) || !((N) OP2 (H)))) {       \
1724         printk(KERN_ERR "\n");                  \
1725         printk(KERN_ERR "AFS: Assertion failed\n");     \
1726         printk(KERN_ERR "%lu "#OP1" %lu "#OP2" %lu is false\n", \
1727                (unsigned long)(L), (unsigned long)(N),      \
1728                (unsigned long)(H));             \
1729         printk(KERN_ERR "0x%lx "#OP1" 0x%lx "#OP2" 0x%lx is false\n", \
1730                (unsigned long)(L), (unsigned long)(N),      \
1731                (unsigned long)(H));             \
1732         BUG();                          \
1733     }                               \
1734 } while(0)
1735 
1736 #define ASSERTIF(C, X)                      \
1737 do {                                \
1738     if (unlikely((C) && !(X))) {                \
1739         printk(KERN_ERR "\n");              \
1740         printk(KERN_ERR "AFS: Assertion failed\n"); \
1741         BUG();                      \
1742     }                           \
1743 } while(0)
1744 
1745 #define ASSERTIFCMP(C, X, OP, Y)                    \
1746 do {                                    \
1747     if (unlikely((C) && !((X) OP (Y)))) {               \
1748         printk(KERN_ERR "\n");                  \
1749         printk(KERN_ERR "AFS: Assertion failed\n");     \
1750         printk(KERN_ERR "%lu " #OP " %lu is false\n",       \
1751                (unsigned long)(X), (unsigned long)(Y));     \
1752         printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n",   \
1753                (unsigned long)(X), (unsigned long)(Y));     \
1754         BUG();                          \
1755     }                               \
1756 } while(0)
1757 
1758 #else
1759 
1760 #define ASSERT(X)               \
1761 do {                        \
1762 } while(0)
1763 
1764 #define ASSERTCMP(X, OP, Y)         \
1765 do {                        \
1766 } while(0)
1767 
1768 #define ASSERTRANGE(L, OP1, N, OP2, H)      \
1769 do {                        \
1770 } while(0)
1771 
1772 #define ASSERTIF(C, X)              \
1773 do {                        \
1774 } while(0)
1775 
1776 #define ASSERTIFCMP(C, X, OP, Y)        \
1777 do {                        \
1778 } while(0)
1779 
1780 #endif /* __KDEBUGALL */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!