summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
96daa1b)
Cleanup the code from GOTO(label, -ERRNO) and other bad GOTOs.
Signed-off-by: Dmitry Eremin <dmitry.eremin@intel.com>
Change-Id: I58df89810c112a6856da83c56c9f29dc22ffdf99
Reviewed-on: http://review.whamcloud.com/8080
Reviewed-by: John L. Hammond <john.hammond@intel.com>
Tested-by: Jenkins
Reviewed-by: James Simmons <uja.ornl@gmail.com>
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>
18 files changed:
LIBCFS_ALLOC(conn->gnc_tx_ref_table, GNILND_MAX_MSG_ID * sizeof(void *));
if (conn->gnc_tx_ref_table == NULL) {
CERROR("Can't allocate conn tx_ref_table\n");
LIBCFS_ALLOC(conn->gnc_tx_ref_table, GNILND_MAX_MSG_ID * sizeof(void *));
if (conn->gnc_tx_ref_table == NULL) {
CERROR("Can't allocate conn tx_ref_table\n");
- rc = -ENOMEM;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENOMEM);
}
atomic_set(&conn->gnc_refcount, 1);
}
atomic_set(&conn->gnc_refcount, 1);
if (conn->gnc_cqid == 0) {
CERROR("Could not allocate unique CQ ID for conn 0x%p\n", conn);
if (conn->gnc_cqid == 0) {
CERROR("Could not allocate unique CQ ID for conn 0x%p\n", conn);
- rc = -E2BIG;
- GOTO(failed, rc);
+ GOTO(failed, rc = -E2BIG);
}
CDEBUG(D_NET, "alloc cqid %u for conn 0x%p\n",
}
CDEBUG(D_NET, "alloc cqid %u for conn 0x%p\n",
rrc = kgnilnd_ep_create(dev->gnd_handle, dev->gnd_snd_fma_cqh,
&conn->gnc_ephandle);
mutex_unlock(&dev->gnd_cq_mutex);
rrc = kgnilnd_ep_create(dev->gnd_handle, dev->gnd_snd_fma_cqh,
&conn->gnc_ephandle);
mutex_unlock(&dev->gnd_cq_mutex);
- if (rrc != GNI_RC_SUCCESS) {
- rc = -ENETDOWN;
- GOTO(failed, rc);
- }
+ if (rrc != GNI_RC_SUCCESS)
+ GOTO(failed, rc = -ENETDOWN);
CDEBUG(D_NET, "created conn 0x%p ep_hndl 0x%p\n",
conn, conn->gnc_ephandle);
CDEBUG(D_NET, "created conn 0x%p ep_hndl 0x%p\n",
conn, conn->gnc_ephandle);
&dev->gnd_domain);
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't create CDM %d (%d)\n", dev->gnd_id, rrc);
&dev->gnd_domain);
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't create CDM %d (%d)\n", dev->gnd_id, rrc);
- rc = -ENODEV;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENODEV);
}
rrc = kgnilnd_cdm_attach(dev->gnd_domain, dev->gnd_id,
}
rrc = kgnilnd_cdm_attach(dev->gnd_domain, dev->gnd_id,
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't attach CDM to device %d (%d)\n",
dev->gnd_id, rrc);
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't attach CDM to device %d (%d)\n",
dev->gnd_id, rrc);
- rc = -ENODEV;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENODEV);
}
/* a bit gross, but not much we can do - Aries Sim doesn't have
* hardcoded NIC/NID that we can use */
rc = kgnilnd_setup_nic_translation(dev->gnd_host_id);
}
/* a bit gross, but not much we can do - Aries Sim doesn't have
* hardcoded NIC/NID that we can use */
rc = kgnilnd_setup_nic_translation(dev->gnd_host_id);
- if (rc != 0) {
- rc = -ENODEV;
- GOTO(failed, rc);
- }
+ if (rc != 0)
+ GOTO(failed, rc = -ENODEV);
/* only dev 0 gets the errors - no need to reset the stack twice
* - this works because we have a single PTAG, if we had more
/* only dev 0 gets the errors - no need to reset the stack twice
* - this works because we have a single PTAG, if we had more
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't subscribe for errors on device %d: rc %d\n",
dev->gnd_id, rrc);
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't subscribe for errors on device %d: rc %d\n",
dev->gnd_id, rrc);
- rc = -ENODEV;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENODEV);
}
rc = kgnilnd_set_quiesce_callback(dev->gnd_handle,
}
rc = kgnilnd_set_quiesce_callback(dev->gnd_handle,
if (rc != GNI_RC_SUCCESS) {
CERROR("Can't subscribe for quiesce callback on device %d: rc %d\n",
dev->gnd_id, rrc);
if (rc != GNI_RC_SUCCESS) {
CERROR("Can't subscribe for quiesce callback on device %d: rc %d\n",
dev->gnd_id, rrc);
- rc = -ENODEV;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENODEV);
CERROR("couldn't translate host_id 0x%x to nid. rc %d\n",
dev->gnd_host_id, rc);
}
CERROR("couldn't translate host_id 0x%x to nid. rc %d\n",
dev->gnd_host_id, rc);
}
- rc = -ESRCH;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ESRCH);
}
CDEBUG(D_NET, "NIC %x -> NID %d\n", dev->gnd_host_id, dev->gnd_nid);
}
CDEBUG(D_NET, "NIC %x -> NID %d\n", dev->gnd_host_id, dev->gnd_nid);
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't create rdma send cq size %u for device "
"%d (%d)\n", cq_size, dev->gnd_id, rrc);
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't create rdma send cq size %u for device "
"%d (%d)\n", cq_size, dev->gnd_id, rrc);
- rc = -EINVAL;
- GOTO(failed, rc);
+ GOTO(failed, rc = -EINVAL);
}
rrc = kgnilnd_cq_create(dev->gnd_handle, cq_size,
}
rrc = kgnilnd_cq_create(dev->gnd_handle, cq_size,
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't create fma send cq size %u for device %d (%d)\n",
cq_size, dev->gnd_id, rrc);
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't create fma send cq size %u for device %d (%d)\n",
cq_size, dev->gnd_id, rrc);
- rc = -EINVAL;
- GOTO(failed, rc);
+ GOTO(failed, rc = -EINVAL);
}
/* This one we size differently - overflows are possible and it needs to be
}
/* This one we size differently - overflows are possible and it needs to be
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't create fma cq size %d for device %d (%d)\n",
*kgnilnd_tunables.kgn_fma_cq_size, dev->gnd_id, rrc);
if (rrc != GNI_RC_SUCCESS) {
CERROR("Can't create fma cq size %d for device %d (%d)\n",
*kgnilnd_tunables.kgn_fma_cq_size, dev->gnd_id, rrc);
- rc = -EINVAL;
- GOTO(failed, rc);
+ GOTO(failed, rc = -EINVAL);
LIBCFS_ALLOC(dev->gnd_dgrams,
sizeof(struct list_head) * *kgnilnd_tunables.kgn_peer_hash_size);
LIBCFS_ALLOC(dev->gnd_dgrams,
sizeof(struct list_head) * *kgnilnd_tunables.kgn_peer_hash_size);
- if (dev->gnd_dgrams == NULL) {
- rc = -ENOMEM;
- GOTO(failed, rc);
- }
+ if (dev->gnd_dgrams == NULL)
+ GOTO(failed, rc = -ENOMEM);
for (i = 0; i < *kgnilnd_tunables.kgn_peer_hash_size; i++) {
INIT_LIST_HEAD(&dev->gnd_dgrams[i]);
for (i = 0; i < *kgnilnd_tunables.kgn_peer_hash_size; i++) {
INIT_LIST_HEAD(&dev->gnd_dgrams[i]);
LIBCFS_ALLOC(kgnilnd_data.kgn_peers,
sizeof(struct list_head) * *kgnilnd_tunables.kgn_peer_hash_size);
LIBCFS_ALLOC(kgnilnd_data.kgn_peers,
sizeof(struct list_head) * *kgnilnd_tunables.kgn_peer_hash_size);
- if (kgnilnd_data.kgn_peers == NULL) {
- rc = -ENOMEM;
- GOTO(failed, rc);
- }
+ if (kgnilnd_data.kgn_peers == NULL)
+ GOTO(failed, rc = -ENOMEM);
for (i = 0; i < *kgnilnd_tunables.kgn_peer_hash_size; i++) {
INIT_LIST_HEAD(&kgnilnd_data.kgn_peers[i]);
for (i = 0; i < *kgnilnd_tunables.kgn_peer_hash_size; i++) {
INIT_LIST_HEAD(&kgnilnd_data.kgn_peers[i]);
LIBCFS_ALLOC(kgnilnd_data.kgn_conns,
sizeof(struct list_head) * *kgnilnd_tunables.kgn_peer_hash_size);
LIBCFS_ALLOC(kgnilnd_data.kgn_conns,
sizeof(struct list_head) * *kgnilnd_tunables.kgn_peer_hash_size);
- if (kgnilnd_data.kgn_conns == NULL) {
- rc = -ENOMEM;
- GOTO(failed, rc);
- }
+ if (kgnilnd_data.kgn_conns == NULL)
+ GOTO(failed, rc = -ENOMEM);
for (i = 0; i < *kgnilnd_tunables.kgn_peer_hash_size; i++) {
INIT_LIST_HEAD(&kgnilnd_data.kgn_conns[i]);
for (i = 0; i < *kgnilnd_tunables.kgn_peer_hash_size; i++) {
INIT_LIST_HEAD(&kgnilnd_data.kgn_conns[i]);
LIBCFS_ALLOC(kgnilnd_data.kgn_nets,
sizeof(struct list_head) * *kgnilnd_tunables.kgn_net_hash_size);
LIBCFS_ALLOC(kgnilnd_data.kgn_nets,
sizeof(struct list_head) * *kgnilnd_tunables.kgn_net_hash_size);
- if (kgnilnd_data.kgn_nets == NULL) {
- rc = -ENOMEM;
- GOTO(failed, rc);
- }
+ if (kgnilnd_data.kgn_nets == NULL)
+ GOTO(failed, rc = -ENOMEM);
for (i = 0; i < *kgnilnd_tunables.kgn_net_hash_size; i++) {
INIT_LIST_HEAD(&kgnilnd_data.kgn_nets[i]);
for (i = 0; i < *kgnilnd_tunables.kgn_net_hash_size; i++) {
INIT_LIST_HEAD(&kgnilnd_data.kgn_nets[i]);
SLAB_HWCACHE_ALIGN, NULL);
if (kgnilnd_data.kgn_mbox_cache == NULL) {
CERROR("Can't create slab for physical mbox blocks\n");
SLAB_HWCACHE_ALIGN, NULL);
if (kgnilnd_data.kgn_mbox_cache == NULL) {
CERROR("Can't create slab for physical mbox blocks\n");
- rc = -ENOMEM;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENOMEM);
}
kgnilnd_data.kgn_rx_cache =
kmem_cache_create("kgn_rx_t", sizeof(kgn_rx_t), 0, 0, NULL);
if (kgnilnd_data.kgn_rx_cache == NULL) {
CERROR("Can't create slab for kgn_rx_t descriptors\n");
}
kgnilnd_data.kgn_rx_cache =
kmem_cache_create("kgn_rx_t", sizeof(kgn_rx_t), 0, 0, NULL);
if (kgnilnd_data.kgn_rx_cache == NULL) {
CERROR("Can't create slab for kgn_rx_t descriptors\n");
- rc = -ENOMEM;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENOMEM);
}
kgnilnd_data.kgn_tx_cache =
kmem_cache_create("kgn_tx_t", sizeof(kgn_tx_t), 0, 0, NULL);
if (kgnilnd_data.kgn_tx_cache == NULL) {
CERROR("Can't create slab for kgn_tx_t\n");
}
kgnilnd_data.kgn_tx_cache =
kmem_cache_create("kgn_tx_t", sizeof(kgn_tx_t), 0, 0, NULL);
if (kgnilnd_data.kgn_tx_cache == NULL) {
CERROR("Can't create slab for kgn_tx_t\n");
- rc = -ENOMEM;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENOMEM);
}
kgnilnd_data.kgn_tx_phys_cache =
}
kgnilnd_data.kgn_tx_phys_cache =
0, 0, NULL);
if (kgnilnd_data.kgn_tx_phys_cache == NULL) {
CERROR("Can't create slab for kgn_tx_phys\n");
0, 0, NULL);
if (kgnilnd_data.kgn_tx_phys_cache == NULL) {
CERROR("Can't create slab for kgn_tx_phys\n");
- rc = -ENOMEM;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENOMEM);
}
kgnilnd_data.kgn_dgram_cache =
kmem_cache_create("kgn_dgram_t", sizeof(kgn_dgram_t), 0, 0, NULL);
if (kgnilnd_data.kgn_dgram_cache == NULL) {
CERROR("Can't create slab for outgoing datagrams\n");
}
kgnilnd_data.kgn_dgram_cache =
kmem_cache_create("kgn_dgram_t", sizeof(kgn_dgram_t), 0, 0, NULL);
if (kgnilnd_data.kgn_dgram_cache == NULL) {
CERROR("Can't create slab for outgoing datagrams\n");
- rc = -ENOMEM;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENOMEM);
}
/* allocate a MAX_IOV array of page pointers for each cpu */
}
/* allocate a MAX_IOV array of page pointers for each cpu */
GFP_KERNEL);
if (kgnilnd_data.kgn_cksum_map_pages == NULL) {
CERROR("Can't allocate vmap cksum pages\n");
GFP_KERNEL);
if (kgnilnd_data.kgn_cksum_map_pages == NULL) {
CERROR("Can't allocate vmap cksum pages\n");
- rc = -ENOMEM;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENOMEM);
}
kgnilnd_data.kgn_cksum_npages = num_possible_cpus();
memset(kgnilnd_data.kgn_cksum_map_pages, 0,
}
kgnilnd_data.kgn_cksum_npages = num_possible_cpus();
memset(kgnilnd_data.kgn_cksum_map_pages, 0,
GFP_KERNEL);
if (kgnilnd_data.kgn_cksum_map_pages[i] == NULL) {
CERROR("Can't allocate vmap cksum pages for cpu %d\n", i);
GFP_KERNEL);
if (kgnilnd_data.kgn_cksum_map_pages[i] == NULL) {
CERROR("Can't allocate vmap cksum pages for cpu %d\n", i);
- rc = -ENOMEM;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENOMEM);
kgnilnd_data.kgn_ndevs++;
rc = kgnilnd_allocate_phys_fmablk(dev);
kgnilnd_data.kgn_ndevs++;
rc = kgnilnd_allocate_phys_fmablk(dev);
}
}
if (kgnilnd_data.kgn_ndevs == 0) {
CERROR("Can't initialise any GNI devices\n");
}
}
if (kgnilnd_data.kgn_ndevs == 0) {
CERROR("Can't initialise any GNI devices\n");
- rc = -ENODEV;
- GOTO(failed, rc);
+ GOTO(failed, rc = -ENODEV);
}
rc = kgnilnd_thread_start(kgnilnd_reaper, NULL, "kgnilnd_rpr", 0);
}
rc = kgnilnd_thread_start(kgnilnd_reaper, NULL, "kgnilnd_rpr", 0);
LIBCFS_ALLOC(net, sizeof(*net));
if (net == NULL) {
CERROR("could not allocate net for new interface instance\n");
LIBCFS_ALLOC(net, sizeof(*net));
if (net == NULL) {
CERROR("could not allocate net for new interface instance\n");
/* no need to cleanup the CDM... */
/* no need to cleanup the CDM... */
+ GOTO(failed, rc = -ENOMEM);
}
INIT_LIST_HEAD(&net->gnn_list);
ni->ni_data = net;
}
INIT_LIST_HEAD(&net->gnn_list);
ni->ni_data = net;
timeout);
ni->ni_data = NULL;
LIBCFS_FREE(net, sizeof(*net));
timeout);
ni->ni_data = NULL;
LIBCFS_FREE(net, sizeof(*net));
- rc = -EINVAL;
- GOTO(failed, rc);
+ GOTO(failed, rc = -EINVAL);
} else
ni->ni_peertimeout = timeout;
} else
ni->ni_peertimeout = timeout;
if (net == NULL) {
CERROR("got NULL net for ni %p\n", ni);
if (net == NULL) {
CERROR("got NULL net for ni %p\n", ni);
- rc = -EINVAL;
- GOTO(out, rc);
+ GOTO(out, rc = -EINVAL);
}
LASSERTF(ni == net->gnn_ni,
}
LASSERTF(ni == net->gnn_ni,
up(&kgnilnd_data.kgn_quiesce_sem);
EXIT;
up(&kgnilnd_data.kgn_quiesce_sem);
EXIT;
lnet_kiov_t *src, *dest;
struct timespec begin, end, diff;
int niov;
lnet_kiov_t *src, *dest;
struct timespec begin, end, diff;
int niov;
int i = 0, j = 0, n;
__u16 cksum, cksum2;
__u64 mbytes;
int i = 0, j = 0, n;
__u16 cksum, cksum2;
__u64 mbytes;
if (src == NULL || dest == NULL) {
CERROR("couldn't allocate iovs\n");
if (src == NULL || dest == NULL) {
CERROR("couldn't allocate iovs\n");
+ GOTO(unwind, rc = -ENOMEM);
}
for (i = 0; i < LNET_MAX_IOV; i++) {
}
for (i = 0; i < LNET_MAX_IOV; i++) {
if (src[i].kiov_page == NULL) {
CERROR("couldn't allocate page %d\n", i);
if (src[i].kiov_page == NULL) {
CERROR("couldn't allocate page %d\n", i);
+ GOTO(unwind, rc = -ENOMEM);
}
dest[i].kiov_offset = 0;
}
dest[i].kiov_offset = 0;
if (dest[i].kiov_page == NULL) {
CERROR("couldn't allocate page %d\n", i);
if (dest[i].kiov_page == NULL) {
CERROR("couldn't allocate page %d\n", i);
+ GOTO(unwind, rc = -ENOMEM);
if (niov > LNET_MAX_IOV) {
CERROR("bytes %d too large, requires niov %d > %d\n",
nob, niov, LNET_MAX_IOV);
if (niov > LNET_MAX_IOV) {
CERROR("bytes %d too large, requires niov %d > %d\n",
nob, niov, LNET_MAX_IOV);
+ GOTO(unwind, rc = -E2BIG);
if (cksum != cksum2) {
CERROR("case %d loop %d different checksums %x expected %x\n",
j, n, cksum2, cksum);
if (cksum != cksum2) {
CERROR("case %d loop %d different checksums %x expected %x\n",
j, n, cksum2, cksum);
+ GOTO(unwind, rc = -ENOKEY);
LIBCFS_FREE(src, LNET_MAX_IOV * sizeof(lnet_kiov_t));
if (dest != NULL)
LIBCFS_FREE(dest, LNET_MAX_IOV * sizeof(lnet_kiov_t));
LIBCFS_FREE(src, LNET_MAX_IOV * sizeof(lnet_kiov_t));
if (dest != NULL)
LIBCFS_FREE(dest, LNET_MAX_IOV * sizeof(lnet_kiov_t));
char dummy[256 + 1] = { '\0' };
int testno, nloops, nbytes;
int rc;
char dummy[256 + 1] = { '\0' };
int testno, nloops, nbytes;
int rc;
if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
CERROR("can't run cksum test, kgnilnd is not initialized yet\n");
if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
CERROR("can't run cksum test, kgnilnd is not initialized yet\n");
}
if (count >= sizeof(dummy) || count == 0)
}
if (count >= sizeof(dummy) || count == 0)
if (copy_from_user(dummy, ubuffer, count))
if (copy_from_user(dummy, ubuffer, count))
if (sscanf(dummy, "%d:%d:%d", &testno, &nloops, &nbytes) == 3) {
rc = _kgnilnd_proc_run_cksum_test(testno, nloops, nbytes);
if (sscanf(dummy, "%d:%d:%d", &testno, &nloops, &nbytes) == 3) {
rc = _kgnilnd_proc_run_cksum_test(testno, nloops, nbytes);
pde = create_proc_entry(GNILND_PROC_CKSUM_TEST, 0200, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_CKSUM_TEST);
pde = create_proc_entry(GNILND_PROC_CKSUM_TEST, 0200, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_CKSUM_TEST);
- rc = -ENOENT;
- GOTO(remove_dir, rc);
+ GOTO(remove_dir, rc = -ENOENT);
pde = create_proc_entry(GNILND_PROC_STATS, 0644, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_STATS);
pde = create_proc_entry(GNILND_PROC_STATS, 0644, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_STATS);
- rc = -ENOENT;
- GOTO(remove_test, rc);
+ GOTO(remove_test, rc = -ENOENT);
pde = create_proc_entry(GNILND_PROC_MDD, 0444, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_MDD);
pde = create_proc_entry(GNILND_PROC_MDD, 0444, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_MDD);
- rc = -ENOENT;
- GOTO(remove_stats, rc);
+ GOTO(remove_stats, rc = -ENOENT);
pde = create_proc_entry(GNILND_PROC_SMSG, 0444, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_SMSG);
pde = create_proc_entry(GNILND_PROC_SMSG, 0444, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_SMSG);
- rc = -ENOENT;
- GOTO(remove_mdd, rc);
+ GOTO(remove_mdd, rc = -ENOENT);
pde = create_proc_entry(GNILND_PROC_CONN, 0444, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_CONN);
pde = create_proc_entry(GNILND_PROC_CONN, 0444, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_CONN);
- rc = -ENOENT;
- GOTO(remove_smsg, rc);
+ GOTO(remove_smsg, rc = -ENOENT);
pde = create_proc_entry(GNILND_PROC_PEER_CONNS, 0644, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_PEER_CONNS);
pde = create_proc_entry(GNILND_PROC_PEER_CONNS, 0644, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_PEER_CONNS);
- rc = -ENOENT;
- GOTO(remove_conn, rc);
+ GOTO(remove_conn, rc = -ENOENT);
pde = create_proc_entry(GNILND_PROC_PEER, 0444, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_PEER);
pde = create_proc_entry(GNILND_PROC_PEER, 0444, kgn_proc_root);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_PEER);
- rc = -ENOENT;
- GOTO(remove_pc, rc);
+ GOTO(remove_pc, rc = -ENOENT);
rc = lprocfs_write_helper(buffer, count, &val);
if (rc != 0) {
CERROR("%s: invalid width.\n", seq->lss_name);
rc = lprocfs_write_helper(buffer, count, &val);
if (rc != 0) {
CERROR("%s: invalid width.\n", seq->lss_name);
+ GOTO(out_unlock, count = rc);
LPROCFS_ENTRY_CHECK(dp);
rc = seq_open(file, &fldb_sops);
if (rc)
LPROCFS_ENTRY_CHECK(dp);
rc = seq_open(file, &fldb_sops);
if (rc)
obj = fld->lsf_obj;
if (obj == NULL) {
obj = fld->lsf_obj;
if (obj == NULL) {
- GOTO(restart, -ERESTART);
}
/* this way we force client to wait for the lock
}
/* this way we force client to wait for the lock
rc = ldlm_run_ast_work(ns, &rpc_list,
LDLM_WORK_CP_AST);
lock_res_and_lock(req);
rc = ldlm_run_ast_work(ns, &rpc_list,
LDLM_WORK_CP_AST);
lock_res_and_lock(req);
- if (rc == -ERESTART)
- GOTO(restart, -ERESTART);
+ if (rc == -ERESTART)
+ GOTO(restart, rc);
}
} else {
LASSERT(req->l_completion_ast);
}
} else {
LASSERT(req->l_completion_ast);
rc = ldlm_run_ast_work(ldlm_res_to_ns(res), &rpc_list,
LDLM_WORK_BL_AST);
lock_res(res);
rc = ldlm_run_ast_work(ldlm_res_to_ns(res), &rpc_list,
LDLM_WORK_BL_AST);
lock_res(res);
- if (rc == -ERESTART)
- GOTO(restart, -ERESTART);
+ if (rc == -ERESTART)
+ GOTO(restart, rc);
*flags |= LDLM_FL_BLOCK_GRANTED;
} else {
ldlm_resource_unlink_lock(lock);
*flags |= LDLM_FL_BLOCK_GRANTED;
} else {
ldlm_resource_unlink_lock(lock);
* need to do anything else. */
*flags &= ~(LDLM_FL_BLOCK_GRANTED |
LDLM_FL_BLOCK_CONV | LDLM_FL_BLOCK_WAIT);
* need to do anything else. */
*flags &= ~(LDLM_FL_BLOCK_GRANTED |
LDLM_FL_BLOCK_CONV | LDLM_FL_BLOCK_WAIT);
+ GOTO(out, rc = ELDLM_OK);
}
ldlm_resource_unlink_lock(lock);
}
ldlm_resource_unlink_lock(lock);
ldlm_resource_add_lock(res, &res->lr_waiting, lock);
else
ldlm_grant_lock(lock, NULL);
ldlm_resource_add_lock(res, &res->lr_waiting, lock);
else
ldlm_grant_lock(lock, NULL);
+ GOTO(out, rc = ELDLM_OK);
#ifdef HAVE_SERVER_SUPPORT
} else if (*flags & LDLM_FL_REPLAY) {
if (*flags & LDLM_FL_BLOCK_CONV) {
ldlm_resource_add_lock(res, &res->lr_converting, lock);
#ifdef HAVE_SERVER_SUPPORT
} else if (*flags & LDLM_FL_REPLAY) {
if (*flags & LDLM_FL_BLOCK_CONV) {
ldlm_resource_add_lock(res, &res->lr_converting, lock);
+ GOTO(out, rc = ELDLM_OK);
} else if (*flags & LDLM_FL_BLOCK_WAIT) {
ldlm_resource_add_lock(res, &res->lr_waiting, lock);
} else if (*flags & LDLM_FL_BLOCK_WAIT) {
ldlm_resource_add_lock(res, &res->lr_waiting, lock);
+ GOTO(out, rc = ELDLM_OK);
} else if (*flags & LDLM_FL_BLOCK_GRANTED) {
ldlm_grant_lock(lock, NULL);
} else if (*flags & LDLM_FL_BLOCK_GRANTED) {
ldlm_grant_lock(lock, NULL);
+ GOTO(out, rc = ELDLM_OK);
}
/* If no flags, fall through to normal enqueue path. */
}
}
/* If no flags, fall through to normal enqueue path. */
}
rc = ldlm_run_ast_work(ldlm_res_to_ns(res), &rpc_list,
LDLM_WORK_BL_AST);
lock_res(res);
rc = ldlm_run_ast_work(ldlm_res_to_ns(res), &rpc_list,
LDLM_WORK_BL_AST);
lock_res(res);
- if (rc == -ERESTART)
- GOTO(restart, -ERESTART);
+ if (rc == -ERESTART)
+ GOTO(restart, rc);
*flags |= LDLM_FL_BLOCK_GRANTED;
} else {
ldlm_resource_unlink_lock(lock);
*flags |= LDLM_FL_BLOCK_GRANTED;
} else {
ldlm_resource_unlink_lock(lock);
}
cl_env_put(env, &refcheck);
}
cl_env_put(env, &refcheck);
- RETURN(tot_bytes ? : result);
+ RETURN(tot_bytes ? tot_bytes : result);
}
static int ll_write_begin(struct file *file, struct address_space *mapping,
}
static int ll_write_begin(struct file *file, struct address_space *mapping,
mdo_ref_add(env, obj, th);
if (!S_ISDIR(mdd_object_type(obj)))
mdo_ref_add(env, obj, th);
if (!S_ISDIR(mdd_object_type(obj)))
mdo_ref_add(env, obj, th);
mdd_orphan_ref_add(env, mdd, th);
mdo_ref_add(env, obj, th);
mdd_orphan_ref_add(env, mdd, th);
/* try best to fixup directory, dont return errors
* from here */
if (!dt_try_as_dir(env, next))
/* try best to fixup directory, dont return errors
* from here */
if (!dt_try_as_dir(env, next))
next->do_index_ops->dio_delete(env, next,
(const struct dt_key *)dotdot,
th, BYPASS_CAPA);
next->do_index_ops->dio_delete(env, next,
(const struct dt_key *)dotdot,
th, BYPASS_CAPA);
tmp->nid_stats = lprocfs_alloc_stats(LPROC_MDT_LAST,
LPROCFS_STATS_FLAG_NOPERCPU);
if (tmp->nid_stats == NULL)
tmp->nid_stats = lprocfs_alloc_stats(LPROC_MDT_LAST,
LPROCFS_STATS_FLAG_NOPERCPU);
if (tmp->nid_stats == NULL)
mdt_stats_counter_init(tmp->nid_stats);
rc = lprocfs_register_stats(tmp->nid_proc, "stats",
tmp->nid_stats);
mdt_stats_counter_init(tmp->nid_stats);
rc = lprocfs_register_stats(tmp->nid_proc, "stats",
tmp->nid_stats);
int obd_init_caches(void)
{
int obd_init_caches(void)
{
ENTRY;
LASSERT(obd_device_cachep == NULL);
ENTRY;
LASSERT(obd_device_cachep == NULL);
sizeof(struct obd_device),
0, 0, NULL);
if (!obd_device_cachep)
sizeof(struct obd_device),
0, 0, NULL);
if (!obd_device_cachep)
+ GOTO(out, rc = -ENOMEM);
LASSERT(obdo_cachep == NULL);
obdo_cachep = kmem_cache_create("ll_obdo_cache", sizeof(struct obdo),
0, 0, NULL);
if (!obdo_cachep)
LASSERT(obdo_cachep == NULL);
obdo_cachep = kmem_cache_create("ll_obdo_cache", sizeof(struct obdo),
0, 0, NULL);
if (!obdo_cachep)
+ GOTO(out, rc = -ENOMEM);
LASSERT(import_cachep == NULL);
import_cachep = kmem_cache_create("ll_import_cache",
sizeof(struct obd_import),
0, 0, NULL);
if (!import_cachep)
LASSERT(import_cachep == NULL);
import_cachep = kmem_cache_create("ll_import_cache",
sizeof(struct obd_import),
0, 0, NULL);
if (!import_cachep)
+ GOTO(out, rc = -ENOMEM);
LASSERT(capa_cachep == NULL);
capa_cachep = kmem_cache_create("capa_cache", sizeof(struct obd_capa),
0, 0, NULL);
if (!capa_cachep)
LASSERT(capa_cachep == NULL);
capa_cachep = kmem_cache_create("capa_cache", sizeof(struct obd_capa),
0, 0, NULL);
if (!capa_cachep)
+ GOTO(out, rc = -ENOMEM);
RETURN(0);
out:
obd_cleanup_caches();
RETURN(0);
out:
obd_cleanup_caches();
}
/* map connection to client */
}
/* map connection to client */
}
case LCFG_SET_PARAM: {
err = process_param2_config(lcfg);
}
case LCFG_SET_PARAM: {
err = process_param2_config(lcfg);
}
}
/* Commands that require a device */
}
}
/* Commands that require a device */
{
struct osd_device *osd = osd_obj2dev(obj);
int plen, off_in_block, sz_in_block;
{
struct osd_device *osd = osd_obj2dev(obj);
int plen, off_in_block, sz_in_block;
+ int rc, i = 0, npages = 0;
arc_buf_t *abuf;
uint32_t bs;
uint64_t dummy;
arc_buf_t *abuf;
uint32_t bs;
uint64_t dummy;
abuf = dmu_request_arcbuf(obj->oo_db, bs);
if (unlikely(abuf == NULL))
abuf = dmu_request_arcbuf(obj->oo_db, bs);
if (unlikely(abuf == NULL))
- GOTO(out_err, -ENOMEM);
+ GOTO(out_err, rc = -ENOMEM);
cfs_atomic_inc(&osd->od_zerocopy_loan);
cfs_atomic_inc(&osd->od_zerocopy_loan);
lnb[i].page = alloc_page(OSD_GFP_IO);
if (unlikely(lnb[i].page == NULL))
lnb[i].page = alloc_page(OSD_GFP_IO);
if (unlikely(lnb[i].page == NULL))
- GOTO(out_err, -ENOMEM);
+ GOTO(out_err, rc = -ENOMEM);
LASSERT(lnb[i].page->mapping == NULL);
lnb[i].page->mapping = (void *)obj;
LASSERT(lnb[i].page->mapping == NULL);
lnb[i].page->mapping = (void *)obj;
out_err:
osd_bufs_put(env, &obj->oo_dt, lnb, npages);
out_err:
osd_bufs_put(env, &obj->oo_dt, lnb, npages);
}
static int osd_bufs_get(const struct lu_env *env, struct dt_object *dt,
}
static int osd_bufs_get(const struct lu_env *env, struct dt_object *dt,
imp->imp_generation == imp->imp_last_generation_checked) {
CDEBUG(D_INFO, "%s: skip recheck: last_committed "LPU64"\n",
imp->imp_obd->obd_name, imp->imp_peer_committed_transno);
imp->imp_generation == imp->imp_last_generation_checked) {
CDEBUG(D_INFO, "%s: skip recheck: last_committed "LPU64"\n",
imp->imp_obd->obd_name, imp->imp_peer_committed_transno);
}
CDEBUG(D_RPCTRACE, "%s: committing for last_committed "LPU64" gen %d\n",
imp->imp_obd->obd_name, imp->imp_peer_committed_transno,
}
CDEBUG(D_RPCTRACE, "%s: committing for last_committed "LPU64" gen %d\n",
imp->imp_obd->obd_name, imp->imp_peer_committed_transno,
}
void ptlrpc_cleanup_client(struct obd_import *imp)
{
ENTRY;
EXIT;
}
void ptlrpc_cleanup_client(struct obd_import *imp)
{
ENTRY;
EXIT;
}
EXPORT_SYMBOL(ptlrpc_cleanup_client);
}
EXPORT_SYMBOL(ptlrpc_cleanup_client);
spin_lock(&imp->imp_lock);
if (imp->imp_state != LUSTRE_IMP_FULL)
spin_lock(&imp->imp_lock);
if (imp->imp_state != LUSTRE_IMP_FULL)
spin_unlock(&imp->imp_lock);
spin_unlock(&imp->imp_lock);
* entry since we keep a reference on ID 0 all the time */
lqe = pool->qpi_grace_lqe[qtype];
lqe_getref(lqe);
* entry since we keep a reference on ID 0 all the time */
lqe = pool->qpi_grace_lqe[qtype];
lqe_getref(lqe);
}
/* now that we have the pool, let's look-up the quota entry in the
}
/* now that we have the pool, let's look-up the quota entry in the
lock = ldlm_handle2lock(&qti->qti_lockh);
if (lock == NULL) {
ptlrpc_req_finished(req);
lock = ldlm_handle2lock(&qti->qti_lockh);
if (lock == NULL) {
ptlrpc_req_finished(req);
+ GOTO(out, rc = -ENOLCK);
}
lu_ref_add(&qqi->qqi_reference, "glb_lock", lock);
LDLM_LOCK_PUT(lock);
}
lu_ref_add(&qqi->qqi_reference, "glb_lock", lock);
LDLM_LOCK_PUT(lock);