double unlock

|static spinlock_t nfs_client_lock = (spinlock_t ) { { .rlock = { .raw_lock = { 0 }, .magic = 0xdead4ead, .owner_cpu = -1, .owner = ((void *)-1L), .dep_map = { .name = "nfs_client_lock" } } } };
|static struct list_head nfs_client_list = { &(nfs_client_list), &(nfs_client_list) };
|static struct list_head nfs_volume_list = { &(nfs_volume_list), &(nfs_volume_list) };
|static wait_queue_head_t nfs_client_active_wq = { .lock = (spinlock_t ) { { .rlock = { .raw_lock = { 0 }, .magic = 0xdead4ead, .owner_cpu = -1, .owner = ((void *)-1L), .dep_map = { .name = "nfs_client_active_wq.lock" } } } }, .task_list = { &(nfs_client_active_wq).task_list, &(nfs_client_active_wq).task_list } };
|
|
|
|
|static struct rpc_version *nfs_version[5] = {
| [2] = &nfs_version2,
|
| [3] = &nfs_version3,
|
|
| [4] = &nfs_version4,
|
|};
|
|struct rpc_program nfs_program = {
| .name = "nfs",
| .number = 100003,
| .nrvers = (sizeof(nfs_version) / sizeof((nfs_version)[0]) + (sizeof(struct { int:-!!(0); }))),
| .version = nfs_version,
| .stats = &nfs_rpcstat,
| .pipe_dir_name = "/nfs",
|};
|
|struct rpc_stat nfs_rpcstat = {
| .program = &nfs_program
|};
|
|
|
|static struct rpc_stat nfsacl_rpcstat = { &nfsacl_program };
|static struct rpc_version * nfsacl_version[] = {
| [3] = &nfsacl_version3,
|};
|
|struct rpc_program nfsacl_program = {
| .name = "nfsacl",
| .number = 100227,
| .nrvers = (sizeof(nfsacl_version) / sizeof((nfsacl_version)[0]) + (sizeof(struct { int:-!!(0); }))),
| .version = nfsacl_version,
| .stats = &nfsacl_rpcstat,
|};
|
|
|struct nfs_client_initdata {
| const char *hostname;
| const struct sockaddr *addr;
| size_t addrlen;
| const struct nfs_rpc_ops *rpc_ops;
| int proto;
| u32 minorversion;
|};
|
|
|
|
|
|
|
|static struct nfs_client *nfs_alloc_client(const struct nfs_client_initdata *cl_init)
|{
| struct nfs_client *clp;
| struct rpc_cred *cred;
| int err = -12;
|
| if ((clp = kzalloc(sizeof(*clp), __st_GFP_KERNEL_st__)) == ((void *)0))
|  goto error_0;
|
| clp->rpc_ops = cl_init->rpc_ops;
|
| atomic_set(&clp->cl_count, 1);
| clp->cl_cons_state = 1;
|
| __st_memcpy_st__(&clp->cl_addr, cl_init->addr, cl_init->addrlen);
| clp->cl_addrlen = cl_init->addrlen;
|
| if (cl_init->hostname) {
|  err = -12;
|  clp->cl_hostname = kstrdup(cl_init->hostname, __st_GFP_KERNEL_st__);
|  if (!clp->cl_hostname)
|   goto error_cleanup;
| }
|
| INIT_LIST_HEAD(&clp->cl_superblocks);
| clp->cl_rpcclient = ERR_PTR(-22);
|
| clp->cl_proto = cl_init->proto;
|
|
| INIT_LIST_HEAD(&clp->cl_delegations);
| do { spinlock_check(&clp->cl_lock); do { static struct lock_class_key __key; __raw_spin_lock_init((&(&clp->cl_lock)->rlock), "&(&clp->cl_lock)->rlock", &__key); } while (0); } while (0);
| do { do { do { static struct lock_class_key __key; __init_work(((&(&clp->cl_renewd)->work)), 0); ((&(&clp->cl_renewd)->work))->data = (atomic_long_t) { (WORK_STRUCT_NO_CPU) }; lockdep_init_map(&((&(&clp->cl_renewd)->work))->lockdep_map, "(&(&clp->cl_renewd)->work)", &__key, 0); INIT_LIST_HEAD(&((&(&clp->cl_renewd)->work))->entry); do { (((&(&clp->cl_renewd)->work)))->func = ((((nfs4_renew_state)))); } while (0); } while (0); } while (0); do { static struct lock_class_key __key; init_timer_key((&(&clp->cl_renewd)->timer), "&(&clp->cl_renewd)->timer", &__key); } while (0); } while (0);
| rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
| clp->cl_boot_time = (current_kernel_time());
| clp->cl_state = 1 << NFS4CLNT_LEASE_EXPIRED;
| clp->cl_minorversion = cl_init->minorversion;
| clp->cl_mvops = nfs_v4_minor_ops[cl_init->minorversion];
|
| cred = rpc_lookup_machine_cred();
| if (!IS_ERR(cred))
|  clp->cl_machine_cred = cred;
|
| INIT_LIST_HEAD(&clp->cl_layouts);
|
| nfs_fscache_get_client_cookie(clp);
|
| return clp;
|
|error_cleanup:
| kfree(clp);
|error_0:
| return ERR_PTR(err);
|}
|
|
|
|
|
|
|static void nfs4_clear_client_minor_version(struct nfs_client *clp)
|{
|
| if (nfs4_has_session(clp)) {
|  nfs4_destroy_session(clp->cl_session);
|  clp->cl_session = ((void *)0);
| }
|
| clp->cl_mvops = nfs_v4_minor_ops[0];
|
|}
|
|
|
|
|static void nfs4_destroy_callback(struct nfs_client *clp)
|{
| if (__test_and_clear_bit(1, &clp->cl_res_state))
|  nfs_callback_down(clp->cl_mvops->minor_version);
|}
|
|static void nfs4_shutdown_client(struct nfs_client *clp)
|{
| if (__test_and_clear_bit(3, &clp->cl_res_state))
|  nfs4_kill_renewd(clp);
| nfs4_clear_client_minor_version(clp);
| nfs4_destroy_callback(clp);
| if (__test_and_clear_bit(2, &clp->cl_res_state))
|  nfs_idmap_delete(clp);
|
| rpc_destroy_wait_queue(&clp->cl_rpcwaitq);
|}
|static void nfs_free_client(struct nfs_client *clp)
|{
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs_free_client(%u)\n", clp->rpc_ops->version); } while(0);
|
| nfs4_shutdown_client(clp);
|
| nfs_fscache_release_client_cookie(clp);
|
|
| if (!IS_ERR(clp->cl_rpcclient))
|  rpc_shutdown_client(clp->cl_rpcclient);
|
| if (clp->cl_machine_cred != ((void *)0))
|  put_rpccred(clp->cl_machine_cred);
|
| kfree(clp->cl_hostname);
| kfree(clp);
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_free_client()\n"); } while(0);
|}
|
|
|
|
|void nfs_put_client(struct nfs_client *clp)
|{
| if (!clp)
     |not affected ==> the lock is still unlocked. prev next
|  return;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs_put_client({%d})\n", atomic_read(&clp->cl_count)); } while(0);
     |not affected ==> the lock is still unlocked. prev next
|
| if ((_atomic_dec_and_lock(&clp->cl_count, &nfs_client_lock))) {
     |not affected ==> the lock is still unlocked. prev next
|  list_del(&clp->cl_share_link);
     |not affected ==> the lock is still unlocked. prev next
|  __st_spin_unlock_st__(&nfs_client_lock);
     |The lock is unlocked and here is an attempt to unlock it twice.[& nfs_client_lock] prev
|
|  __st_BUG_ON_st__(!list_empty(&clp->cl_superblocks));
|
|  nfs_free_client(clp);
| }
|}
|extern typeof(nfs_put_client) nfs_put_client; extern void *__crc_nfs_put_client ; static const unsigned long __kcrctab_nfs_put_client = (unsigned long) &__crc_nfs_put_client; static const char __kstrtab_nfs_put_client[] = "" "nfs_put_client"; static const struct kernel_symbol __ksymtab_nfs_put_client = { (unsigned long)&nfs_put_client, __kstrtab_nfs_put_client };
|static int nfs_sockaddr_match_ipaddr6(const struct sockaddr *sa1,
|          const struct sockaddr *sa2)
|{
| const struct sockaddr_in6 *sin1 = (const struct sockaddr_in6 *)sa1;
| const struct sockaddr_in6 *sin2 = (const struct sockaddr_in6 *)sa2;
|
| if (ipv6_addr_scope(&sin1->sin6_addr) == 0x02 &&
|     sin1->sin6_scope_id != sin2->sin6_scope_id)
|  return 0;
|
| return ipv6_addr_equal(&sin1->sin6_addr, &sin2->sin6_addr);
|}
|static int nfs_sockaddr_match_ipaddr4(const struct sockaddr *sa1,
|          const struct sockaddr *sa2)
|{
| const struct sockaddr_in *sin1 = (const struct sockaddr_in *)sa1;
| const struct sockaddr_in *sin2 = (const struct sockaddr_in *)sa2;
|
| return sin1->sin_addr.s_addr == sin2->sin_addr.s_addr;
|}
|
|static int nfs_sockaddr_cmp_ip6(const struct sockaddr *sa1,
|    const struct sockaddr *sa2)
|{
| const struct sockaddr_in6 *sin1 = (const struct sockaddr_in6 *)sa1;
| const struct sockaddr_in6 *sin2 = (const struct sockaddr_in6 *)sa2;
|
| return nfs_sockaddr_match_ipaddr6(sa1, sa2) &&
|  (sin1->sin6_port == sin2->sin6_port);
|}
|
|static int nfs_sockaddr_cmp_ip4(const struct sockaddr *sa1,
|    const struct sockaddr *sa2)
|{
| const struct sockaddr_in *sin1 = (const struct sockaddr_in *)sa1;
| const struct sockaddr_in *sin2 = (const struct sockaddr_in *)sa2;
|
| return nfs_sockaddr_match_ipaddr4(sa1, sa2) &&
|  (sin1->sin_port == sin2->sin_port);
|}
|
|
|
|
|
|static int nfs_sockaddr_match_ipaddr(const struct sockaddr *sa1,
|         const struct sockaddr *sa2)
|{
| if (sa1->sa_family != sa2->sa_family)
|  return 0;
|
| switch (sa1->sa_family) {
| case 2:
|  return nfs_sockaddr_match_ipaddr4(sa1, sa2);
| case 10:
|  return nfs_sockaddr_match_ipaddr6(sa1, sa2);
| }
| return 0;
|}
|
|
|
|
|
|static int nfs_sockaddr_cmp(const struct sockaddr *sa1,
|       const struct sockaddr *sa2)
|{
| if (sa1->sa_family != sa2->sa_family)
|  return 0;
|
| switch (sa1->sa_family) {
| case 2:
|  return nfs_sockaddr_cmp_ip4(sa1, sa2);
| case 10:
|  return nfs_sockaddr_cmp_ip6(sa1, sa2);
| }
| return 0;
|}
|
|
|
|
|
|struct nfs_client *nfs_find_client(const struct sockaddr *addr, u32 nfsversion)
|{
| struct nfs_client *clp;
|
| __st_spin_lock_st__(&nfs_client_lock);
| for (clp = ({ const typeof( ((typeof(*clp) *)0)->cl_share_link ) *__mptr = ((&nfs_client_list)->next); (typeof(*clp) *)( (char *)__mptr - 1 );}); __builtin_prefetch(clp->cl_share_link.next), &clp->cl_share_link != (&nfs_client_list); clp = ({ const typeof( ((typeof(*clp) *)0)->cl_share_link ) *__mptr = (clp->cl_share_link.next); (typeof(*clp) *)( (char *)__mptr - 1 );})) {
|  struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
|
|
|  if (!(clp->cl_cons_state == 0 ||
|        clp->cl_cons_state == 2))
|   continue;
|
|
|  if (clp->rpc_ops->version != nfsversion)
|   continue;
|
|
|  if (!nfs_sockaddr_match_ipaddr(addr, clap))
|   continue;
|
|  atomic_inc(&clp->cl_count);
|  __st_spin_unlock_st__(&nfs_client_lock);
|  return clp;
| }
| __st_spin_unlock_st__(&nfs_client_lock);
| return ((void *)0);
|}
|
|
|
|
|
|struct nfs_client *nfs_find_client_next(struct nfs_client *clp)
|{
| struct sockaddr *sap = (struct sockaddr *)&clp->cl_addr;
| u32 nfsvers = clp->rpc_ops->version;
|
| __st_spin_lock_st__(&nfs_client_lock);
| for (clp = ({ const typeof( ((typeof(*clp) *)0)->cl_share_link ) *__mptr = (clp->cl_share_link.next); (typeof(*clp) *)( (char *)__mptr - 1 );}); __builtin_prefetch(clp->cl_share_link.next), &clp->cl_share_link != (&nfs_client_list); clp = ({ const typeof( ((typeof(*clp) *)0)->cl_share_link ) *__mptr = (clp->cl_share_link.next); (typeof(*clp) *)( (char *)__mptr - 1 );})) {
|  struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
|
|
|  if (clp->cl_cons_state != 0)
|   continue;
|
|
|  if (clp->rpc_ops->version != nfsvers)
|   continue;
|
|
|  if (!nfs_sockaddr_match_ipaddr(sap, clap))
|   continue;
|
|  atomic_inc(&clp->cl_count);
|  __st_spin_unlock_st__(&nfs_client_lock);
|  return clp;
| }
| __st_spin_unlock_st__(&nfs_client_lock);
| return ((void *)0);
|}
|
|
|
|
|
|static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *data)
|{
| struct nfs_client *clp;
| const struct sockaddr *sap = data->addr;
|
| for (clp = ({ const typeof( ((typeof(*clp) *)0)->cl_share_link ) *__mptr = ((&nfs_client_list)->next); (typeof(*clp) *)( (char *)__mptr - 1 );}); __builtin_prefetch(clp->cl_share_link.next), &clp->cl_share_link != (&nfs_client_list); clp = ({ const typeof( ((typeof(*clp) *)0)->cl_share_link ) *__mptr = (clp->cl_share_link.next); (typeof(*clp) *)( (char *)__mptr - 1 );})) {
|         const struct sockaddr *clap = (struct sockaddr *)&clp->cl_addr;
|
|  if (clp->cl_cons_state < 0)
|   continue;
|
|
|  if (clp->rpc_ops != data->rpc_ops)
|   continue;
|
|  if (clp->cl_proto != data->proto)
|   continue;
|
|  if (clp->cl_minorversion != data->minorversion)
|   continue;
|
|  if (!nfs_sockaddr_cmp(sap, clap))
|   continue;
|
|  atomic_inc(&clp->cl_count);
|  return clp;
| }
| return ((void *)0);
|}
|
|
|
|
|
|static struct nfs_client *nfs_get_client(const struct nfs_client_initdata *cl_init)
|{
| struct nfs_client *clp, *new = ((void *)0);
| int error;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs_get_client(%s,v%u)\n", cl_init->hostname ?: "", cl_init->rpc_ops->version); } while(0)
|                                                     ;
|
|
| do {
|  __st_spin_lock_st__(&nfs_client_lock);
|
|  clp = nfs_match_client(cl_init);
|  if (clp)
|   goto found_client;
|  if (new)
|   goto install_client;
|
|  __st_spin_unlock_st__(&nfs_client_lock);
|
|  new = nfs_alloc_client(cl_init);
| } while (!IS_ERR(new));
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs_get_client() = %ld [failed]\n", PTR_ERR(new)); } while(0);
| return new;
|
|
|install_client:
| clp = new;
| list_add(&clp->cl_share_link, &nfs_client_list);
| __st_spin_unlock_st__(&nfs_client_lock);
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs_get_client() = %p [new]\n", clp); } while(0);
| return clp;
|
|
|
|
|found_client:
| __st_spin_unlock_st__(&nfs_client_lock);
|
| if (new)
|  nfs_free_client(new);
|
| error = ({ int __ret = 0; if (!(clp->cl_cons_state < 1)) do { wait_queue_t __wait = { .private = get_current(), .func = autoremove_wake_function, .task_list = { &((__wait).task_list), &((__wait).task_list) }, }; for (;;) { prepare_to_wait(&nfs_client_active_wq, &__wait, (128 | 2)); if (clp->cl_cons_state < 1) break; if (!fatal_signal_pending(get_current())) { schedule(); continue; } __ret = -512; break; } finish_wait(&nfs_client_active_wq, &__wait); } while (0); __ret; })
|                                        ;
| if (error < 0) {
|  nfs_put_client(clp);
|  return ERR_PTR(-512);
| }
|
| if (clp->cl_cons_state < 0) {
|  error = clp->cl_cons_state;
|  nfs_put_client(clp);
|  return ERR_PTR(error);
| }
|
| __st_BUG_ON_st__(clp->cl_cons_state != 0);
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs_get_client() = %p [share]\n", clp); } while(0);
| return clp;
|}
|
|
|
|
|void nfs_mark_client_ready(struct nfs_client *clp, int state)
|{
| clp->cl_cons_state = state;
| __wake_up(&nfs_client_active_wq, (1 | 2), 0, ((void *)0));
|}
|int nfs4_check_client_ready(struct nfs_client *clp)
|{
| if (!nfs4_has_session(clp))
|  return 0;
| if (clp->cl_cons_state < 0)
|  return -93;
| return 0;
|}
|
|
|
|
|static void nfs_init_timeout_values(struct rpc_timeout *to, int proto,
|        unsigned int timeo, unsigned int retrans)
|{
| to->to_initval = timeo * 250 / 10;
| to->to_retries = retrans;
|
| switch (proto) {
| case XPRT_TRANSPORT_TCP:
| case XPRT_TRANSPORT_RDMA:
|  if (to->to_retries == 0)
|   to->to_retries = (2);
|  if (to->to_initval == 0)
|   to->to_initval = (600) * 250 / 10;
|  if (to->to_initval > (600*250))
|   to->to_initval = (600*250);
|  to->to_increment = to->to_initval;
|  to->to_maxval = to->to_initval + (to->to_increment * to->to_retries);
|  if (to->to_maxval > (600*250))
|   to->to_maxval = (600*250);
|  if (to->to_maxval < to->to_initval)
|   to->to_maxval = to->to_initval;
|  to->to_exponential = 0;
|  break;
| case XPRT_TRANSPORT_UDP:
|  if (to->to_retries == 0)
|   to->to_retries = (3);
|  if (!to->to_initval)
|   to->to_initval = (11) * 250 / 10;
|  if (to->to_initval > (60*250))
|   to->to_initval = (60*250);
|  to->to_maxval = (60*250);
|  to->to_exponential = 1;
|  break;
| default:
|  __st_BUG_st__();
| }
|}
|
|
|
|
|static int nfs_create_rpc_client(struct nfs_client *clp,
|     const struct rpc_timeout *timeparms,
|     rpc_authflavor_t flavor,
|     int discrtry, int noresvport)
|{
| struct rpc_clnt *clnt = ((void *)0);
| struct rpc_create_args args = {
|  .net = &init_net,
|  .protocol = clp->cl_proto,
|  .address = (struct sockaddr *)&clp->cl_addr,
|  .addrsize = clp->cl_addrlen,
|  .timeout = timeparms,
|  .servername = clp->cl_hostname,
|  .program = &nfs_program,
|  .version = clp->rpc_ops->version,
|  .authflavor = flavor,
| };
|
| if (discrtry)
|  args.flags |= (1UL << 5);
| if (noresvport)
|  args.flags |= (1UL << 3);
|
| if (!IS_ERR(clp->cl_rpcclient))
|  return 0;
|
| clnt = rpc_create(&args);
| if (IS_ERR(clnt)) {
|  do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("%s: cannot create RPC client. Error = %ld\n", __func__, PTR_ERR(clnt)); } while(0)
|                            ;
|  return PTR_ERR(clnt);
| }
|
| clp->cl_rpcclient = clnt;
| return 0;
|}
|
|
|
|
|static void nfs_destroy_server(struct nfs_server *server)
|{
| if (!(server->flags & 0x100000) ||
|   !(server->flags & 0x200000))
|  nlmclnt_done(server->nlm_host);
|}
|
|
|
|
|static int nfs_start_lockd(struct nfs_server *server)
|{
| struct nlm_host *host;
| struct nfs_client *clp = server->nfs_client;
| struct nlmclnt_initdata nlm_init = {
|  .hostname = clp->cl_hostname,
|  .address = (struct sockaddr *)&clp->cl_addr,
|  .addrlen = clp->cl_addrlen,
|  .nfs_version = clp->rpc_ops->version,
|  .noresvport = server->flags & 0x40000 ?
|     1 : 0,
| };
|
| if (nlm_init.nfs_version > 3)
|  return 0;
| if ((server->flags & 0x100000) &&
|   (server->flags & 0x200000))
|  return 0;
|
| switch (clp->cl_proto) {
|  default:
|   nlm_init.protocol = IPPROTO_TCP;
|   break;
|  case XPRT_TRANSPORT_UDP:
|   nlm_init.protocol = IPPROTO_UDP;
| }
|
| host = nlmclnt_init(&nlm_init);
| if (IS_ERR(host))
|  return PTR_ERR(host);
|
| server->nlm_host = host;
| server->destroy = nfs_destroy_server;
| return 0;
|}
|
|
|
|
|
|static void nfs_init_server_aclclient(struct nfs_server *server)
|{
| if (server->nfs_client->rpc_ops->version != 3)
|  goto out_noacl;
| if (server->flags & 0x0800)
|  goto out_noacl;
|
| server->client_acl = rpc_bind_new_program(server->client, &nfsacl_program, 3);
| if (IS_ERR(server->client_acl))
|  goto out_noacl;
|
|
| server->caps |= (1U << 3);
| return;
|
|out_noacl:
| server->caps &= ~(1U << 3);
|}
|static int nfs_init_server_rpcclient(struct nfs_server *server,
|  const struct rpc_timeout *timeo,
|  rpc_authflavor_t pseudoflavour)
|{
| struct nfs_client *clp = server->nfs_client;
|
| server->client = rpc_clone_client(clp->cl_rpcclient);
| if (IS_ERR(server->client)) {
|  do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("%s: couldn't create rpc_client!\n", __func__); } while(0);
|  return PTR_ERR(server->client);
| }
|
| __st_memcpy_st__(&server->client->cl_timeout_default,
|   timeo,
|   sizeof(server->client->cl_timeout_default));
| server->client->cl_timeout = &server->client->cl_timeout_default;
|
| if (pseudoflavour != clp->cl_rpcclient->cl_auth->au_flavor) {
|  struct rpc_auth *auth;
|
|  auth = rpcauth_create(pseudoflavour, server->client);
|  if (IS_ERR(auth)) {
|   do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("%s: couldn't create credcache!\n", __func__); } while(0);
|   return PTR_ERR(auth);
|  }
| }
| server->client->cl_softrtry = 0;
| if (server->flags & 0x0001)
|  server->client->cl_softrtry = 1;
|
| return 0;
|}
|
|
|
|
|static int nfs_init_client(struct nfs_client *clp,
|      const struct rpc_timeout *timeparms,
|      const struct nfs_parsed_mount_data *data)
|{
| int error;
|
| if (clp->cl_cons_state == 0) {
|
|  do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_init_client() = 0 [already %p]\n", clp); } while(0);
|  return 0;
| }
|
|
|
|
|
| error = nfs_create_rpc_client(clp, timeparms, RPC_AUTH_UNIX,
|          0, data->flags & 0x40000);
| if (error < 0)
|  goto error;
| nfs_mark_client_ready(clp, 0);
| return 0;
|
|error:
| nfs_mark_client_ready(clp, error);
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_init_client() = xerror %d\n", error); } while(0);
| return error;
|}
|
|
|
|
|static int nfs_init_server(struct nfs_server *server,
|      const struct nfs_parsed_mount_data *data)
|{
| struct nfs_client_initdata cl_init = {
|  .hostname = data->nfs_server.hostname,
|  .addr = (const struct sockaddr *)&data->nfs_server.address,
|  .addrlen = data->nfs_server.addrlen,
|  .rpc_ops = &nfs_v2_clientops,
|  .proto = data->nfs_server.protocol,
| };
| struct rpc_timeout timeparms;
| struct nfs_client *clp;
| int error;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs_init_server()\n"); } while(0);
|
|
| if (data->version == 3)
|  cl_init.rpc_ops = &nfs_v3_clientops;
|
|
|
| clp = nfs_get_client(&cl_init);
| if (IS_ERR(clp)) {
|  do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_init_server() = error %ld\n", PTR_ERR(clp)); } while(0);
|  return PTR_ERR(clp);
| }
|
| nfs_init_timeout_values(&timeparms, data->nfs_server.protocol,
|   data->timeo, data->retrans);
| error = nfs_init_client(clp, &timeparms, data);
| if (error < 0)
|  goto error;
|
| server->nfs_client = clp;
|
|
| server->flags = data->flags;
| server->options = data->options;
| server->caps |= (1U << 1)|(1U << 2)|(1U << 6)|
|  (1U << 7)|(1U << 8)|(1U << 9)|(1U << 10)|
|  (1U << 11)|(1U << 12)|(1U << 13);
|
| if (data->rsize)
|  server->rsize = nfs_block_size(data->rsize, ((void *)0));
| if (data->wsize)
|  server->wsize = nfs_block_size(data->wsize, ((void *)0));
|
| server->acregmin = data->acregmin * 250;
| server->acregmax = data->acregmax * 250;
| server->acdirmin = data->acdirmin * 250;
| server->acdirmax = data->acdirmax * 250;
|
|
| error = nfs_start_lockd(server);
| if (error < 0)
|  goto error;
|
| server->port = data->nfs_server.port;
|
| error = nfs_init_server_rpcclient(server, &timeparms, data->auth_flavors[0]);
| if (error < 0)
|  goto error;
|
|
| if (data->mount_server.addrlen) {
|  __st_memcpy_st__(&server->mountd_address, &data->mount_server.address,
|   data->mount_server.addrlen);
|  server->mountd_addrlen = data->mount_server.addrlen;
| }
| server->mountd_version = data->mount_server.version;
| server->mountd_port = data->mount_server.port;
| server->mountd_protocol = data->mount_server.protocol;
|
| server->namelen = data->namlen;
|
| nfs_init_server_aclclient(server);
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_init_server() = 0 [new %p]\n", clp); } while(0);
| return 0;
|
|error:
| server->nfs_client = ((void *)0);
| nfs_put_client(clp);
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_init_server() = xerror %d\n", error); } while(0);
| return error;
|}
|
|
|
|
|static void nfs_server_set_fsinfo(struct nfs_server *server, struct nfs_fsinfo *fsinfo)
|{
| unsigned long max_rpc_payload;
|
|
| if (server->rsize == 0)
|  server->rsize = nfs_block_size(fsinfo->rtpref, ((void *)0));
| if (server->wsize == 0)
|  server->wsize = nfs_block_size(fsinfo->wtpref, ((void *)0));
|
| if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)
|  server->rsize = nfs_block_size(fsinfo->rtmax, ((void *)0));
| if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
|  server->wsize = nfs_block_size(fsinfo->wtmax, ((void *)0));
|
| max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), ((void *)0));
| if (server->rsize > max_rpc_payload)
|  server->rsize = max_rpc_payload;
| if (server->rsize > (1048576U))
|  server->rsize = (1048576U);
| server->rpages = (server->rsize + ((1UL) << 12) - 1) >> 12;
|
| server->backing_dev_info.name = "nfs";
| server->backing_dev_info.ra_pages = server->rpages * ((16U) - 1);
|
| if (server->wsize > max_rpc_payload)
|  server->wsize = max_rpc_payload;
| if (server->wsize > (1048576U))
|  server->wsize = (1048576U);
| server->wpages = (server->wsize + ((1UL) << 12) - 1) >> 12;
| set_pnfs_layoutdriver(server, fsinfo->layouttype);
|
| server->wtmult = nfs_block_bits(fsinfo->wtmult, ((void *)0));
|
| server->dtsize = nfs_block_size(fsinfo->dtpref, ((void *)0));
| if (server->dtsize > ((1UL) << 12) * 8)
|  server->dtsize = ((1UL) << 12) * 8;
| if (server->dtsize > server->rsize)
|  server->dtsize = server->rsize;
|
| if (server->flags & 0x0020) {
|  server->acregmin = server->acregmax = 0;
|  server->acdirmin = server->acdirmax = 0;
| }
|
| server->maxfilesize = fsinfo->maxfilesize;
|
| server->time_delta = fsinfo->time_delta;
|
|
| rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
|}
|
|
|
|
|static int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, struct nfs_fattr *fattr)
|{
| struct nfs_fsinfo fsinfo;
| struct nfs_client *clp = server->nfs_client;
| int error;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs_probe_fsinfo()\n"); } while(0);
|
| if (clp->rpc_ops->set_capabilities != ((void *)0)) {
|  error = clp->rpc_ops->set_capabilities(server, mntfh);
|  if (error < 0)
|   goto out_error;
| }
|
| fsinfo.fattr = fattr;
| fsinfo.layouttype = 0;
| error = clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);
| if (error < 0)
|  goto out_error;
|
| nfs_server_set_fsinfo(server, &fsinfo);
|
|
| if (server->namelen == 0) {
|  struct nfs_pathconf pathinfo;
|
|  pathinfo.fattr = fattr;
|  nfs_fattr_init(fattr);
|
|  if (clp->rpc_ops->pathconf(server, mntfh, &pathinfo) >= 0)
|   server->namelen = pathinfo.max_namelen;
| }
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_probe_fsinfo() = 0\n"); } while(0);
| return 0;
|
|out_error:
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("nfs_probe_fsinfo: error = %d\n", -error); } while(0);
| return error;
|}
|
|
|
|
|static void nfs_server_copy_userdata(struct nfs_server *target, struct nfs_server *source)
|{
| target->flags = source->flags;
| target->rsize = source->rsize;
| target->wsize = source->wsize;
| target->acregmin = source->acregmin;
| target->acregmax = source->acregmax;
| target->acdirmin = source->acdirmin;
| target->acdirmax = source->acdirmax;
| target->caps = source->caps;
| target->options = source->options;
|}
|
|
|
|
|static struct nfs_server *nfs_alloc_server(void)
|{
| struct nfs_server *server;
|
| server = kzalloc(sizeof(struct nfs_server), __st_GFP_KERNEL_st__);
| if (!server)
|  return ((void *)0);
|
| server->client = server->client_acl = ERR_PTR(-22);
|
|
| INIT_LIST_HEAD(&server->client_link);
| INIT_LIST_HEAD(&server->master_link);
|
| atomic_set(&server->active, 0);
|
| server->io_stats = nfs_alloc_iostats();
| if (!server->io_stats) {
|  kfree(server);
|  return ((void *)0);
| }
|
| if (bdi_init(&server->backing_dev_info)) {
|  nfs_free_iostats(server->io_stats);
|  kfree(server);
|  return ((void *)0);
| }
|
| return server;
|}
|
|
|
|
|void nfs_free_server(struct nfs_server *server)
|{
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs_free_server()\n"); } while(0);
|
| unset_pnfs_layoutdriver(server);
| __st_spin_lock_st__(&nfs_client_lock);
| list_del(&server->client_link);
| list_del(&server->master_link);
| __st_spin_unlock_st__(&nfs_client_lock);
     |The lock is unlocked here. prev next
|
| if (server->destroy != ((void *)0))
     |not affected ==> the lock is still unlocked. prev next
|  server->destroy(server);
|
| if (!IS_ERR(server->client_acl))
     |not affected ==> the lock is still unlocked. prev next
|  rpc_shutdown_client(server->client_acl);
| if (!IS_ERR(server->client))
     |not affected ==> the lock is still unlocked. prev next
|  rpc_shutdown_client(server->client);
|
| nfs_put_client(server->nfs_client);
     |not affected ==> the lock is still unlocked. prev next
|
| nfs_free_iostats(server->io_stats);
| bdi_destroy(&server->backing_dev_info);
| kfree(server);
| nfs_release_automount_timer();
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_free_server()\n"); } while(0);
|}
|
|
|
|
|
|struct nfs_server *nfs_create_server(const struct nfs_parsed_mount_data *data,
|         struct nfs_fh *mntfh)
|{
| struct nfs_server *server;
| struct nfs_fattr *fattr;
| int error;
|
| server = nfs_alloc_server();
| if (!server)
|  return ERR_PTR(-12);
|
| error = -12;
| fattr = nfs_alloc_fattr();
| if (fattr == ((void *)0))
|  goto error;
|
|
| error = nfs_init_server(server, data);
| if (error < 0)
|  goto error;
|
| __st_BUG_ON_st__(!server->nfs_client);
| __st_BUG_ON_st__(!server->nfs_client->rpc_ops);
| __st_BUG_ON_st__(!server->nfs_client->rpc_ops->file_inode_ops);
|
|
| error = nfs_probe_fsinfo(server, mntfh, fattr);
| if (error < 0)
|  goto error;
| if (server->nfs_client->rpc_ops->version == 3) {
|  if (server->namelen == 0 || server->namelen > 255)
|   server->namelen = 255;
|  if (!(data->flags & 0x4000))
|   server->caps |= (1U << 0);
| } else {
|  if (server->namelen == 0 || server->namelen > 255)
|   server->namelen = 255;
| }
|
| if (!(fattr->valid & ((1U << 0) | (1U << 1) | (1U << 2) | (1U << 3) | (1U << 4) | (1U << 5) | (1U << 6) | (1U << 10) | (1U << 11) | (1U << 12) | (1U << 13) | (1U << 14)))) {
|  error = server->nfs_client->rpc_ops->getattr(server, mntfh, fattr);
|  if (error < 0) {
|   do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("nfs_create_server: getattr error = %d\n", -error); } while(0);
|   goto error;
|  }
| }
| __st_memcpy_st__(&server->fsid, &fattr->fsid, sizeof(server->fsid));
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("Server FSID: %llx:%llx\n", (unsigned long long) server->fsid.major, (unsigned long long) server->fsid.minor); } while(0)
|
|                                          ;
|
| __st_spin_lock_st__(&nfs_client_lock);
| list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
| list_add_tail(&server->master_link, &nfs_volume_list);
| __st_spin_unlock_st__(&nfs_client_lock);
|
| server->mount_time = jiffies;
| nfs_free_fattr(fattr);
| return server;
|
|error:
| nfs_free_fattr(fattr);
| nfs_free_server(server);
| return ERR_PTR(error);
|}
|
|
|
|
|
|static int nfs4_init_callback(struct nfs_client *clp)
|{
| int error;
|
| if (clp->rpc_ops->version == 4) {
|  if (nfs4_has_session(clp)) {
|   error = xprt_setup_backchannel(
|      clp->cl_rpcclient->cl_xprt,
|      1);
|   if (error < 0)
|    return error;
|  }
|
|  error = nfs_callback_up(clp->cl_mvops->minor_version,
|     clp->cl_rpcclient->cl_xprt);
|  if (error < 0) {
|   do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("%s: failed to start callback. Error = %d\n", __func__, error); } while(0)
|                    ;
|   return error;
|  }
|  __set_bit(1, &clp->cl_res_state);
| }
| return 0;
|}
|
|
|
|
|static int nfs4_init_client_minor_version(struct nfs_client *clp)
|{
|
| if (clp->cl_mvops->minor_version) {
|  struct nfs4_session *session = ((void *)0);
|
|
|
|
|
|  session = nfs4_alloc_session(clp);
|  if (!session)
|   return -12;
|
|  clp->cl_session = session;
|
|
|
|
|
|
|  clp->cl_cons_state = 2;
| }
|
|
| return nfs4_init_callback(clp);
|}
|
|
|
|
|static int nfs4_init_client(struct nfs_client *clp,
|  const struct rpc_timeout *timeparms,
|  const char *ip_addr,
|  rpc_authflavor_t authflavour,
|  int flags)
|{
| int error;
|
| if (clp->cl_cons_state == 0) {
|
|  do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs4_init_client() = 0 [already %p]\n", clp); } while(0);
|  return 0;
| }
|
|
| clp->rpc_ops = &nfs_v4_clientops;
|
| error = nfs_create_rpc_client(clp, timeparms, authflavour,
|          1, flags & 0x40000);
| if (error < 0)
|  goto error;
| strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr));
|
| error = nfs_idmap_new(clp);
| if (error < 0) {
|  do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("%s: failed to create idmapper. Error = %d\n", __func__, error); } while(0)
|                   ;
|  goto error;
| }
| __set_bit(2, &clp->cl_res_state);
|
| error = nfs4_init_client_minor_version(clp);
| if (error < 0)
|  goto error;
|
| if (!nfs4_has_session(clp))
|  nfs_mark_client_ready(clp, 0);
| return 0;
|
|error:
| nfs_mark_client_ready(clp, error);
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs4_init_client() = xerror %d\n", error); } while(0);
| return error;
|}
|
|
|
|
|static int nfs4_set_client(struct nfs_server *server,
|  const char *hostname,
|  const struct sockaddr *addr,
|  const size_t addrlen,
|  const char *ip_addr,
|  rpc_authflavor_t authflavour,
|  int proto, const struct rpc_timeout *timeparms,
|  u32 minorversion)
|{
| struct nfs_client_initdata cl_init = {
|  .hostname = hostname,
|  .addr = addr,
|  .addrlen = addrlen,
|  .rpc_ops = &nfs_v4_clientops,
|  .proto = proto,
|  .minorversion = minorversion,
| };
| struct nfs_client *clp;
| int error;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs4_set_client()\n"); } while(0);
|
|
| clp = nfs_get_client(&cl_init);
| if (IS_ERR(clp)) {
|  error = PTR_ERR(clp);
|  goto error;
| }
| error = nfs4_init_client(clp, timeparms, ip_addr, authflavour,
|     server->flags);
| if (error < 0)
|  goto error_put;
|
| server->nfs_client = clp;
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs4_set_client() = 0 [new %p]\n", clp); } while(0);
| return 0;
|
|error_put:
| nfs_put_client(clp);
|error:
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs4_set_client() = xerror %d\n", error); } while(0);
| return error;
|}
|
|
|
|
|
|
|
|static void nfs4_session_set_rwsize(struct nfs_server *server)
|{
|
| struct nfs4_session *sess;
| u32 server_resp_sz;
| u32 server_rqst_sz;
|
| if (!nfs4_has_session(server->nfs_client))
|  return;
| sess = server->nfs_client->cl_session;
| server_resp_sz = sess->fc_attrs.max_resp_sz - nfs41_maxread_overhead;
| server_rqst_sz = sess->fc_attrs.max_rqst_sz - nfs41_maxwrite_overhead;
|
| if (server->rsize > server_resp_sz)
|  server->rsize = server_resp_sz;
| if (server->wsize > server_rqst_sz)
|  server->wsize = server_rqst_sz;
|
|}
|
|static int nfs4_server_common_setup(struct nfs_server *server,
|  struct nfs_fh *mntfh)
|{
| struct nfs_fattr *fattr;
| int error;
|
| __st_BUG_ON_st__(!server->nfs_client);
| __st_BUG_ON_st__(!server->nfs_client->rpc_ops);
| __st_BUG_ON_st__(!server->nfs_client->rpc_ops->file_inode_ops);
|
| fattr = nfs_alloc_fattr();
| if (fattr == ((void *)0))
|  return -12;
|
|
| error = nfs4_init_session(server);
| if (error < 0)
|  goto out;
|
|
| error = nfs4_get_rootfh(server, mntfh);
| if (error < 0)
|  goto out;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("Server FSID: %llx:%llx\n", (unsigned long long) server->fsid.major, (unsigned long long) server->fsid.minor); } while(0)
|
|                                           ;
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("Mount FH: %d\n", mntfh->size); } while(0);
|
| nfs4_session_set_rwsize(server);
|
| error = nfs_probe_fsinfo(server, mntfh, fattr);
| if (error < 0)
|  goto out;
|
| if (server->namelen == 0 || server->namelen > 255)
|  server->namelen = 255;
|
| __st_spin_lock_st__(&nfs_client_lock);
| list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
| list_add_tail(&server->master_link, &nfs_volume_list);
| __st_spin_unlock_st__(&nfs_client_lock);
|
| server->mount_time = jiffies;
|out:
| nfs_free_fattr(fattr);
| return error;
|}
|
|
|
|
|static int nfs4_init_server(struct nfs_server *server,
|  const struct nfs_parsed_mount_data *data)
|{
| struct rpc_timeout timeparms;
| int error;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs4_init_server()\n"); } while(0);
|
| nfs_init_timeout_values(&timeparms, data->nfs_server.protocol,
|   data->timeo, data->retrans);
|
|
| server->flags = data->flags;
| server->caps |= (1U << 4)|(1U << 5)|(1U << 14);
| if (!(data->flags & 0x4000))
|   server->caps |= (1U << 0);
| server->options = data->options;
|
|
| error = nfs4_set_client(server,
|   data->nfs_server.hostname,
|   (const struct sockaddr *)&data->nfs_server.address,
|   data->nfs_server.addrlen,
|   data->client_address,
|   data->auth_flavors[0],
|   data->nfs_server.protocol,
|   &timeparms,
|   data->minorversion);
| if (error < 0)
|  goto error;
|
| if (data->rsize)
|  server->rsize = nfs_block_size(data->rsize, ((void *)0));
| if (data->wsize)
|  server->wsize = nfs_block_size(data->wsize, ((void *)0));
|
| server->acregmin = data->acregmin * 250;
| server->acregmax = data->acregmax * 250;
| server->acdirmin = data->acdirmin * 250;
| server->acdirmax = data->acdirmax * 250;
|
| server->port = data->nfs_server.port;
|
| error = nfs_init_server_rpcclient(server, &timeparms, data->auth_flavors[0]);
|
|error:
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs4_init_server() = %d\n", error); } while(0);
| return error;
|}
|
|
|
|
|
|struct nfs_server *nfs4_create_server(const struct nfs_parsed_mount_data *data,
|          struct nfs_fh *mntfh)
|{
| struct nfs_server *server;
| int error;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs4_create_server()\n"); } while(0);
|
| server = nfs_alloc_server();
| if (!server)
|  return ERR_PTR(-12);
|
|
| error = nfs4_init_server(server, data);
| if (error < 0)
|  goto error;
|
| error = nfs4_server_common_setup(server, mntfh);
| if (error < 0)
|  goto error;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs4_create_server() = %p\n", server); } while(0);
| return server;
|
|error:
| nfs_free_server(server);
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs4_create_server() = error %d\n", error); } while(0);
| return ERR_PTR(error);
|}
|
|
|
|
|struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
|            struct nfs_fh *mntfh)
|{
| struct nfs_client *parent_client;
| struct nfs_server *server, *parent_server;
| int error;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs4_create_referral_server()\n"); } while(0);
|
| server = nfs_alloc_server();
| if (!server)
|  return ERR_PTR(-12);
|
| parent_server = NFS_SB(data->sb);
| parent_client = parent_server->nfs_client;
|
|
| nfs_server_copy_userdata(server, parent_server);
| server->caps |= (1U << 4)|(1U << 5);
|
|
|
| error = nfs4_set_client(server, data->hostname,
|    data->addr,
|    data->addrlen,
|    parent_client->cl_ipaddr,
|    data->authflavor,
|    parent_server->client->cl_xprt->prot,
|    parent_server->client->cl_timeout,
|    parent_client->cl_mvops->minor_version);
| if (error < 0)
|  goto error;
|
| error = nfs_init_server_rpcclient(server, parent_server->client->cl_timeout, data->authflavor);
| if (error < 0)
|  goto error;
|
| error = nfs4_server_common_setup(server, mntfh);
| if (error < 0)
|  goto error;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_create_referral_server() = %p\n", server); } while(0);
| return server;
|
|error:
| nfs_free_server(server);
     |<context>When called from here. next
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs4_create_referral_server() = error %d\n", error); } while(0);
| return ERR_PTR(error);
|}
|
|
|
|
|
|
|struct nfs_server *nfs_clone_server(struct nfs_server *source,
|        struct nfs_fh *fh,
|        struct nfs_fattr *fattr)
|{
| struct nfs_server *server;
| struct nfs_fattr *fattr_fsinfo;
| int error;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("--> nfs_clone_server(,%llx:%llx,)\n", (unsigned long long) fattr->fsid.major, (unsigned long long) fattr->fsid.minor); } while(0)
|
|                                         ;
|
| server = nfs_alloc_server();
| if (!server)
|  return ERR_PTR(-12);
|
| error = -12;
| fattr_fsinfo = nfs_alloc_fattr();
| if (fattr_fsinfo == ((void *)0))
|  goto out_free_server;
|
|
| server->nfs_client = source->nfs_client;
| atomic_inc(&server->nfs_client->cl_count);
| nfs_server_copy_userdata(server, source);
|
| server->fsid = fattr->fsid;
|
| error = nfs_init_server_rpcclient(server,
|   source->client->cl_timeout,
|   source->client->cl_auth->au_flavor);
| if (error < 0)
|  goto out_free_server;
| if (!IS_ERR(source->client_acl))
|  nfs_init_server_aclclient(server);
|
|
| error = nfs_probe_fsinfo(server, fh, fattr_fsinfo);
| if (error < 0)
|  goto out_free_server;
|
| if (server->namelen == 0 || server->namelen > 255)
|  server->namelen = 255;
|
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("Cloned FSID: %llx:%llx\n", (unsigned long long) server->fsid.major, (unsigned long long) server->fsid.minor); } while(0)
|
|                                          ;
|
| error = nfs_start_lockd(server);
| if (error < 0)
|  goto out_free_server;
|
| __st_spin_lock_st__(&nfs_client_lock);
| list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
| list_add_tail(&server->master_link, &nfs_volume_list);
| __st_spin_unlock_st__(&nfs_client_lock);
|
| server->mount_time = jiffies;
|
| nfs_free_fattr(fattr_fsinfo);
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_clone_server() = %p\n", server); } while(0);
| return server;
|
|out_free_server:
| nfs_free_fattr(fattr_fsinfo);
| nfs_free_server(server);
| do { if (__builtin_expect(!!(nfs_debug & 0x0200), 0)) printk("<-- nfs_clone_server() = error %d\n", error); } while(0);
| return ERR_PTR(error);
|}
|
|
|static struct proc_dir_entry *proc_fs_nfs;
|
|static int nfs_server_list_open(struct inode *inode, struct file *file);
|static void *nfs_server_list_start(struct seq_file *p, loff_t *pos);
|static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos);
|static void nfs_server_list_stop(struct seq_file *p, void *v);
|static int nfs_server_list_show(struct seq_file *m, void *v);
|
|static const struct seq_operations nfs_server_list_ops = {
| .start = nfs_server_list_start,
| .next = nfs_server_list_next,
| .stop = nfs_server_list_stop,
| .show = nfs_server_list_show,
|};
|
|static const struct file_operations nfs_server_list_fops = {
| .open = nfs_server_list_open,
| .read = seq_read,
| .llseek = seq_lseek,
| .release = seq_release,
| .owner = (&__this_module),
|};
|
|static int nfs_volume_list_open(struct inode *inode, struct file *file);
|static void *nfs_volume_list_start(struct seq_file *p, loff_t *pos);
|static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos);
|static void nfs_volume_list_stop(struct seq_file *p, void *v);
|static int nfs_volume_list_show(struct seq_file *m, void *v);
|
|static const struct seq_operations nfs_volume_list_ops = {
| .start = nfs_volume_list_start,
| .next = nfs_volume_list_next,
| .stop = nfs_volume_list_stop,
| .show = nfs_volume_list_show,
|};
|
|static const struct file_operations nfs_volume_list_fops = {
| .open = nfs_volume_list_open,
| .read = seq_read,
| .llseek = seq_lseek,
| .release = seq_release,
| .owner = (&__this_module),
|};
|
|
|
|
|
|static int nfs_server_list_open(struct inode *inode, struct file *file)
|{
| struct seq_file *m;
| int ret;
|
| ret = seq_open(file, &nfs_server_list_ops);
| if (ret < 0)
|  return ret;
|
| m = file->private_data;
| m->private = PDE(inode)->data;
|
| return 0;
|}
|
|
|
|
|static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
|{
|
| __st_spin_lock_st__(&nfs_client_lock);
| return seq_list_start_head(&nfs_client_list, *_pos);
|}
|
|
|
|
|static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
|{
| return seq_list_next(v, &nfs_client_list, pos);
|}
|
|
|
|
|static void nfs_server_list_stop(struct seq_file *p, void *v)
|{
| __st_spin_unlock_st__(&nfs_client_lock);
|}
|
|
|
|
|static int nfs_server_list_show(struct seq_file *m, void *v)
|{
| struct nfs_client *clp;
|
|
| if (v == &nfs_client_list) {
|  seq_puts(m, "NV SERVER   PORT USE HOSTNAME\n");
|  return 0;
| }
|
|
| clp = ({ const typeof( ((struct nfs_client *)0)->cl_share_link ) *__mptr = (v); (struct nfs_client *)( (char *)__mptr - 1 );});
|
| seq_printf(m, "v%u %s %s %3d %s\n",
|     clp->rpc_ops->version,
|     rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
|     rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
|     atomic_read(&clp->cl_count),
|     clp->cl_hostname);
|
| return 0;
|}
|
|
|
|
|static int nfs_volume_list_open(struct inode *inode, struct file *file)
|{
| struct seq_file *m;
| int ret;
|
| ret = seq_open(file, &nfs_volume_list_ops);
| if (ret < 0)
|  return ret;
|
| m = file->private_data;
| m->private = PDE(inode)->data;
|
| return 0;
|}
|
|
|
|
|static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
|{
|
| __st_spin_lock_st__(&nfs_client_lock);
| return seq_list_start_head(&nfs_volume_list, *_pos);
|}
|
|
|
|
|static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
|{
| return seq_list_next(v, &nfs_volume_list, pos);
|}
|
|
|
|
|static void nfs_volume_list_stop(struct seq_file *p, void *v)
|{
| __st_spin_unlock_st__(&nfs_client_lock);
|}
|
|
|
|
|static int nfs_volume_list_show(struct seq_file *m, void *v)
|{
| struct nfs_server *server;
| struct nfs_client *clp;
| char dev[8], fsid[17];
|
|
| if (v == &nfs_volume_list) {
|  seq_puts(m, "NV SERVER   PORT DEV     FSID              FSC\n");
|  return 0;
| }
|
| server = ({ const typeof( ((struct nfs_server *)0)->master_link ) *__mptr = (v); (struct nfs_server *)( (char *)__mptr - 1 );});
| clp = server->nfs_client;
|
| snprintf(dev, 8, "%u:%u",
|   ((unsigned int) ((server->s_dev) >> 20)), ((unsigned int) ((server->s_dev) & ((1U << 20) - 1))));
|
| snprintf(fsid, 17, "%llx:%llx",
|   (unsigned long long) server->fsid.major,
|   (unsigned long long) server->fsid.minor);
|
| seq_printf(m, "v%u %s %s %-7s %-17s %s\n",
|     clp->rpc_ops->version,
|     rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_ADDR),
|     rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_HEX_PORT),
|     dev,
|     fsid,
|     nfs_server_fscache_state(server));
|
| return 0;
|}
|
|
|
|
|int nfs_fs_proc_init(void)
|{
| struct proc_dir_entry *p;
|
| proc_fs_nfs = proc_mkdir("fs/nfsfs", ((void *)0));
| if (!proc_fs_nfs)
|  goto error_0;
|
|
| p = proc_create("servers", 0100000|(00400|00040|00004),
|   proc_fs_nfs, &nfs_server_list_fops);
| if (!p)
|  goto error_1;
|
|
| p = proc_create("volumes", 0100000|(00400|00040|00004),
|   proc_fs_nfs, &nfs_volume_list_fops);
| if (!p)
|  goto error_2;
| return 0;
|
|error_2:
| remove_proc_entry("servers", proc_fs_nfs);
|error_1:
| remove_proc_entry("fs/nfsfs", ((void *)0));
|error_0:
| return -12;
|}
|
|
|
|
|void nfs_fs_proc_exit(void)
|{
| remove_proc_entry("volumes", proc_fs_nfs);
| remove_proc_entry("servers", proc_fs_nfs);
| remove_proc_entry("fs/nfsfs", ((void *)0));
|}