Lines Matching refs:ctx
160 struct spu_context *ctx = i->i_ctx;
162 mutex_lock(&ctx->mapping_lock);
163 file->private_data = ctx;
165 ctx->local_store = inode->i_mapping;
166 mutex_unlock(&ctx->mapping_lock);
174 struct spu_context *ctx = i->i_ctx;
176 mutex_lock(&ctx->mapping_lock);
178 ctx->local_store = NULL;
179 mutex_unlock(&ctx->mapping_lock);
184 spufs_mem_dump(struct spu_context *ctx, struct coredump_params *cprm)
186 return spufs_dump_emit(cprm, ctx->ops->get_ls(ctx), LS_SIZE);
193 struct spu_context *ctx = file->private_data;
196 ret = spu_acquire(ctx);
199 ret = simple_read_from_buffer(buffer, size, pos, ctx->ops->get_ls(ctx),
201 spu_release(ctx);
210 struct spu_context *ctx = file->private_data;
218 ret = spu_acquire(ctx);
222 local_store = ctx->ops->get_ls(ctx);
224 spu_release(ctx);
233 struct spu_context *ctx = vma->vm_file->private_data;
244 if (spu_acquire(ctx))
247 if (ctx->state == SPU_STATE_SAVED) {
249 pfn = vmalloc_to_pfn(ctx->csa.lscsa->ls + offset);
252 pfn = (ctx->spu->local_store_phys + offset) >> PAGE_SHIFT;
256 spu_release(ctx);
265 struct spu_context *ctx = vma->vm_file->private_data;
271 if (spu_acquire(ctx))
275 local_store = ctx->ops->get_ls(ctx);
280 spu_release(ctx);
314 struct spu_context *ctx = vmf->vma->vm_file->private_data;
319 spu_context_nospu_trace(spufs_ps_fault__enter, ctx);
332 get_spu_context(ctx);
342 if (spu_acquire(ctx))
345 if (ctx->state == SPU_STATE_SAVED) {
347 spu_context_nospu_trace(spufs_ps_fault__sleep, ctx);
348 err = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE);
349 spu_context_trace(spufs_ps_fault__wake, ctx, ctx->spu);
352 area = ctx->spu->problem_phys + ps_offs;
355 spu_context_trace(spufs_ps_fault__insert, ctx, ctx->spu);
359 spu_release(ctx);
362 put_spu_context(ctx);
396 struct spu_context *ctx = data;
399 ret = spu_acquire(ctx);
402 *val = ctx->ops->status_read(ctx);
403 spu_release(ctx);
410 struct spu_context *ctx = data;
413 ret = spu_acquire(ctx);
416 ctx->ops->runcntl_write(ctx, val);
417 spu_release(ctx);
425 struct spu_context *ctx = i->i_ctx;
427 mutex_lock(&ctx->mapping_lock);
428 file->private_data = ctx;
430 ctx->cntl = inode->i_mapping;
431 mutex_unlock(&ctx->mapping_lock);
440 struct spu_context *ctx = i->i_ctx;
444 mutex_lock(&ctx->mapping_lock);
446 ctx->cntl = NULL;
447 mutex_unlock(&ctx->mapping_lock);
469 spufs_regs_dump(struct spu_context *ctx, struct coredump_params *cprm)
471 return spufs_dump_emit(cprm, ctx->csa.lscsa->gprs,
472 sizeof(ctx->csa.lscsa->gprs));
480 struct spu_context *ctx = file->private_data;
484 if (*pos >= sizeof(ctx->csa.lscsa->gprs))
487 ret = spu_acquire_saved(ctx);
490 ret = simple_read_from_buffer(buffer, size, pos, ctx->csa.lscsa->gprs,
491 sizeof(ctx->csa.lscsa->gprs));
492 spu_release_saved(ctx);
500 struct spu_context *ctx = file->private_data;
501 struct spu_lscsa *lscsa = ctx->csa.lscsa;
507 ret = spu_acquire_saved(ctx);
514 spu_release_saved(ctx);
526 spufs_fpcr_dump(struct spu_context *ctx, struct coredump_params *cprm)
528 return spufs_dump_emit(cprm, &ctx->csa.lscsa->fpcr,
529 sizeof(ctx->csa.lscsa->fpcr));
537 struct spu_context *ctx = file->private_data;
539 ret = spu_acquire_saved(ctx);
542 ret = simple_read_from_buffer(buffer, size, pos, &ctx->csa.lscsa->fpcr,
543 sizeof(ctx->csa.lscsa->fpcr));
544 spu_release_saved(ctx);
552 struct spu_context *ctx = file->private_data;
553 struct spu_lscsa *lscsa = ctx->csa.lscsa;
559 ret = spu_acquire_saved(ctx);
566 spu_release_saved(ctx);
597 struct spu_context *ctx = file->private_data;
604 count = spu_acquire(ctx);
610 ret = ctx->ops->mbox_read(ctx, &mbox_data);
626 spu_release(ctx);
643 struct spu_context *ctx = file->private_data;
650 ret = spu_acquire(ctx);
654 mbox_stat = ctx->ops->mbox_stat_read(ctx) & 0xff;
656 spu_release(ctx);
671 size_t spu_ibox_read(struct spu_context *ctx, u32 *data)
673 return ctx->ops->ibox_read(ctx, data);
679 struct spu_context *ctx = spu->ctx;
681 if (ctx)
682 wake_up_all(&ctx->ibox_wq);
700 struct spu_context *ctx = file->private_data;
707 count = spu_acquire(ctx);
714 if (!spu_ibox_read(ctx, &ibox_data)) {
719 count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data));
731 ret = ctx->ops->ibox_read(ctx, &ibox_data);
745 spu_release(ctx);
752 struct spu_context *ctx = file->private_data;
755 poll_wait(file, &ctx->ibox_wq, wait);
761 mutex_lock(&ctx->state_mutex);
762 mask = ctx->ops->mbox_stat_poll(ctx, EPOLLIN | EPOLLRDNORM);
763 spu_release(ctx);
778 struct spu_context *ctx = file->private_data;
785 ret = spu_acquire(ctx);
788 ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff;
789 spu_release(ctx);
804 size_t spu_wbox_write(struct spu_context *ctx, u32 data)
806 return ctx->ops->wbox_write(ctx, data);
812 struct spu_context *ctx = spu->ctx;
814 if (ctx)
815 wake_up_all(&ctx->wbox_wq);
833 struct spu_context *ctx = file->private_data;
843 count = spu_acquire(ctx);
853 if (!spu_wbox_write(ctx, wbox_data)) {
858 count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data));
871 ret = spu_wbox_write(ctx, wbox_data);
877 spu_release(ctx);
884 struct spu_context *ctx = file->private_data;
887 poll_wait(file, &ctx->wbox_wq, wait);
893 mutex_lock(&ctx->state_mutex);
894 mask = ctx->ops->mbox_stat_poll(ctx, EPOLLOUT | EPOLLWRNORM);
895 spu_release(ctx);
910 struct spu_context *ctx = file->private_data;
917 ret = spu_acquire(ctx);
920 wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff;
921 spu_release(ctx);
938 struct spu_context *ctx = i->i_ctx;
940 mutex_lock(&ctx->mapping_lock);
941 file->private_data = ctx;
943 ctx->signal1 = inode->i_mapping;
944 mutex_unlock(&ctx->mapping_lock);
952 struct spu_context *ctx = i->i_ctx;
954 mutex_lock(&ctx->mapping_lock);
956 ctx->signal1 = NULL;
957 mutex_unlock(&ctx->mapping_lock);
961 static ssize_t spufs_signal1_dump(struct spu_context *ctx,
964 if (!ctx->csa.spu_chnlcnt_RW[3])
966 return spufs_dump_emit(cprm, &ctx->csa.spu_chnldata_RW[3],
967 sizeof(ctx->csa.spu_chnldata_RW[3]));
970 static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf,
973 if (len < sizeof(ctx->csa.spu_chnldata_RW[3]))
975 if (!ctx->csa.spu_chnlcnt_RW[3])
977 if (copy_to_user(buf, &ctx->csa.spu_chnldata_RW[3],
978 sizeof(ctx->csa.spu_chnldata_RW[3])))
980 return sizeof(ctx->csa.spu_chnldata_RW[3]);
987 struct spu_context *ctx = file->private_data;
989 ret = spu_acquire_saved(ctx);
992 ret = __spufs_signal1_read(ctx, buf, len);
993 spu_release_saved(ctx);
1001 struct spu_context *ctx;
1005 ctx = file->private_data;
1013 ret = spu_acquire(ctx);
1016 ctx->ops->signal1_write(ctx, data);
1017 spu_release(ctx);
1073 struct spu_context *ctx = i->i_ctx;
1075 mutex_lock(&ctx->mapping_lock);
1076 file->private_data = ctx;
1078 ctx->signal2 = inode->i_mapping;
1079 mutex_unlock(&ctx->mapping_lock);
1087 struct spu_context *ctx = i->i_ctx;
1089 mutex_lock(&ctx->mapping_lock);
1091 ctx->signal2 = NULL;
1092 mutex_unlock(&ctx->mapping_lock);
1096 static ssize_t spufs_signal2_dump(struct spu_context *ctx,
1099 if (!ctx->csa.spu_chnlcnt_RW[4])
1101 return spufs_dump_emit(cprm, &ctx->csa.spu_chnldata_RW[4],
1102 sizeof(ctx->csa.spu_chnldata_RW[4]));
1105 static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf,
1108 if (len < sizeof(ctx->csa.spu_chnldata_RW[4]))
1110 if (!ctx->csa.spu_chnlcnt_RW[4])
1112 if (copy_to_user(buf, &ctx->csa.spu_chnldata_RW[4],
1113 sizeof(ctx->csa.spu_chnldata_RW[4])))
1115 return sizeof(ctx->csa.spu_chnldata_RW[4]);
1121 struct spu_context *ctx = file->private_data;
1124 ret = spu_acquire_saved(ctx);
1127 ret = __spufs_signal2_read(ctx, buf, len);
1128 spu_release_saved(ctx);
1136 struct spu_context *ctx;
1140 ctx = file->private_data;
1148 ret = spu_acquire(ctx);
1151 ctx->ops->signal2_write(ctx, data);
1152 spu_release(ctx);
1221 struct spu_context *ctx = data; \
1225 ret = spu_acquire(ctx); \
1228 *val = __get(ctx); \
1229 spu_release(ctx); \
1231 ret = spu_acquire_saved(ctx); \
1234 *val = __get(ctx); \
1235 spu_release_saved(ctx); \
1237 *val = __get(ctx); \
1245 struct spu_context *ctx = data;
1248 ret = spu_acquire(ctx);
1251 ctx->ops->signal1_type_set(ctx, val);
1252 spu_release(ctx);
1257 static u64 spufs_signal1_type_get(struct spu_context *ctx)
1259 return ctx->ops->signal1_type_get(ctx);
1267 struct spu_context *ctx = data;
1270 ret = spu_acquire(ctx);
1273 ctx->ops->signal2_type_set(ctx, val);
1274 spu_release(ctx);
1279 static u64 spufs_signal2_type_get(struct spu_context *ctx)
1281 return ctx->ops->signal2_type_get(ctx);
1318 struct spu_context *ctx = i->i_ctx;
1322 mutex_lock(&ctx->mapping_lock);
1324 ctx->mss = inode->i_mapping;
1325 mutex_unlock(&ctx->mapping_lock);
1333 struct spu_context *ctx = i->i_ctx;
1335 mutex_lock(&ctx->mapping_lock);
1337 ctx->mss = NULL;
1338 mutex_unlock(&ctx->mapping_lock);
1377 struct spu_context *ctx = i->i_ctx;
1379 mutex_lock(&ctx->mapping_lock);
1382 ctx->psmap = inode->i_mapping;
1383 mutex_unlock(&ctx->mapping_lock);
1391 struct spu_context *ctx = i->i_ctx;
1393 mutex_lock(&ctx->mapping_lock);
1395 ctx->psmap = NULL;
1396 mutex_unlock(&ctx->mapping_lock);
1440 struct spu_context *ctx = i->i_ctx;
1443 if (ctx->owner != current->mm)
1449 mutex_lock(&ctx->mapping_lock);
1450 file->private_data = ctx;
1452 ctx->mfc = inode->i_mapping;
1453 mutex_unlock(&ctx->mapping_lock);
1461 struct spu_context *ctx = i->i_ctx;
1463 mutex_lock(&ctx->mapping_lock);
1465 ctx->mfc = NULL;
1466 mutex_unlock(&ctx->mapping_lock);
1473 struct spu_context *ctx = spu->ctx;
1475 if (ctx)
1476 wake_up_all(&ctx->mfc_wq);
1479 static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status)
1483 *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait;
1484 ctx->tagwait &= ~*status;
1490 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1497 struct spu_context *ctx = file->private_data;
1504 ret = spu_acquire(ctx);
1510 status = ctx->ops->read_mfc_tagstatus(ctx);
1511 if (!(status & ctx->tagwait))
1515 ctx->tagwait &= ~status;
1517 ret = spufs_wait(ctx->mfc_wq,
1518 spufs_read_mfc_tagstatus(ctx, &status));
1522 spu_release(ctx);
1602 static int spu_send_mfc_command(struct spu_context *ctx,
1606 *error = ctx->ops->send_mfc_command(ctx, &cmd);
1610 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1613 *error = ctx->ops->send_mfc_command(ctx, &cmd);
1623 struct spu_context *ctx = file->private_data;
1638 ret = spu_acquire(ctx);
1642 ret = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE);
1647 ret = ctx->ops->send_mfc_command(ctx, &cmd);
1650 ret = spufs_wait(ctx->mfc_wq,
1651 spu_send_mfc_command(ctx, cmd, &status));
1661 ctx->tagwait |= 1 << cmd.tag;
1665 spu_release(ctx);
1672 struct spu_context *ctx = file->private_data;
1676 poll_wait(file, &ctx->mfc_wq, wait);
1682 mutex_lock(&ctx->state_mutex);
1683 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2);
1684 free_elements = ctx->ops->get_mfc_free_elements(ctx);
1685 tagstatus = ctx->ops->read_mfc_tagstatus(ctx);
1686 spu_release(ctx);
1691 if (tagstatus & ctx->tagwait)
1695 free_elements, tagstatus, ctx->tagwait);
1702 struct spu_context *ctx = file->private_data;
1705 ret = spu_acquire(ctx);
1710 ret = spufs_wait(ctx->mfc_wq,
1711 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2));
1714 ret = spufs_wait(ctx->mfc_wq,
1715 ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait);
1721 spu_release(ctx);
1752 struct spu_context *ctx = data;
1755 ret = spu_acquire(ctx);
1758 ctx->ops->npc_write(ctx, val);
1759 spu_release(ctx);
1764 static u64 spufs_npc_get(struct spu_context *ctx)
1766 return ctx->ops->npc_read(ctx);
1773 struct spu_context *ctx = data;
1774 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1777 ret = spu_acquire_saved(ctx);
1781 spu_release_saved(ctx);
1786 static u64 spufs_decr_get(struct spu_context *ctx)
1788 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1796 struct spu_context *ctx = data;
1799 ret = spu_acquire_saved(ctx);
1803 ctx->csa.priv2.mfc_control_RW |= MFC_CNTL_DECREMENTER_RUNNING;
1805 ctx->csa.priv2.mfc_control_RW &= ~MFC_CNTL_DECREMENTER_RUNNING;
1806 spu_release_saved(ctx);
1811 static u64 spufs_decr_status_get(struct spu_context *ctx)
1813 if (ctx->csa.priv2.mfc_control_RW & MFC_CNTL_DECREMENTER_RUNNING)
1824 struct spu_context *ctx = data;
1825 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1828 ret = spu_acquire_saved(ctx);
1832 spu_release_saved(ctx);
1837 static u64 spufs_event_mask_get(struct spu_context *ctx)
1839 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1847 static u64 spufs_event_status_get(struct spu_context *ctx)
1849 struct spu_state *state = &ctx->csa;
1861 struct spu_context *ctx = data;
1862 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1865 ret = spu_acquire_saved(ctx);
1869 spu_release_saved(ctx);
1874 static u64 spufs_srr0_get(struct spu_context *ctx)
1876 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1882 static u64 spufs_id_get(struct spu_context *ctx)
1886 if (ctx->state == SPU_STATE_RUNNABLE)
1887 num = ctx->spu->number;
1896 static u64 spufs_object_id_get(struct spu_context *ctx)
1899 return ctx->object_id;
1904 struct spu_context *ctx = data;
1905 ctx->object_id = id;
1913 static u64 spufs_lslr_get(struct spu_context *ctx)
1915 return ctx->csa.priv2.spu_lslr_RW;
1923 struct spu_context *ctx = i->i_ctx;
1924 file->private_data = ctx;
1930 struct spu_context *ctx = s->private;
1932 if (!(ctx->flags & SPU_CREATE_NOSCHED))
1934 if (!(ctx->flags & SPU_CREATE_ISOLATE))
1951 static ssize_t spufs_mbox_info_dump(struct spu_context *ctx,
1954 if (!(ctx->csa.prob.mb_stat_R & 0x0000ff))
1956 return spufs_dump_emit(cprm, &ctx->csa.prob.pu_mb_R,
1957 sizeof(ctx->csa.prob.pu_mb_R));
1963 struct spu_context *ctx = file->private_data;
1967 ret = spu_acquire_saved(ctx);
1970 spin_lock(&ctx->csa.register_lock);
1971 stat = ctx->csa.prob.mb_stat_R;
1972 data = ctx->csa.prob.pu_mb_R;
1973 spin_unlock(&ctx->csa.register_lock);
1974 spu_release_saved(ctx);
1989 static ssize_t spufs_ibox_info_dump(struct spu_context *ctx,
1992 if (!(ctx->csa.prob.mb_stat_R & 0xff0000))
1994 return spufs_dump_emit(cprm, &ctx->csa.priv2.puint_mb_R,
1995 sizeof(ctx->csa.priv2.puint_mb_R));
2001 struct spu_context *ctx = file->private_data;
2005 ret = spu_acquire_saved(ctx);
2008 spin_lock(&ctx->csa.register_lock);
2009 stat = ctx->csa.prob.mb_stat_R;
2010 data = ctx->csa.priv2.puint_mb_R;
2011 spin_unlock(&ctx->csa.register_lock);
2012 spu_release_saved(ctx);
2027 static size_t spufs_wbox_info_cnt(struct spu_context *ctx)
2029 return (4 - ((ctx->csa.prob.mb_stat_R & 0x00ff00) >> 8)) * sizeof(u32);
2032 static ssize_t spufs_wbox_info_dump(struct spu_context *ctx,
2035 return spufs_dump_emit(cprm, &ctx->csa.spu_mailbox_data,
2036 spufs_wbox_info_cnt(ctx));
2042 struct spu_context *ctx = file->private_data;
2043 u32 data[ARRAY_SIZE(ctx->csa.spu_mailbox_data)];
2046 ret = spu_acquire_saved(ctx);
2049 spin_lock(&ctx->csa.register_lock);
2050 count = spufs_wbox_info_cnt(ctx);
2051 memcpy(&data, &ctx->csa.spu_mailbox_data, sizeof(data));
2052 spin_unlock(&ctx->csa.register_lock);
2053 spu_release_saved(ctx);
2065 static void spufs_get_dma_info(struct spu_context *ctx,
2070 info->dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW;
2071 info->dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0];
2072 info->dma_info_status = ctx->csa.spu_chnldata_RW[24];
2073 info->dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25];
2074 info->dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27];
2077 struct mfc_cq_sr *spuqp = &ctx->csa.priv2.spuq[i];
2086 static ssize_t spufs_dma_info_dump(struct spu_context *ctx,
2091 spufs_get_dma_info(ctx, &info);
2098 struct spu_context *ctx = file->private_data;
2102 ret = spu_acquire_saved(ctx);
2105 spin_lock(&ctx->csa.register_lock);
2106 spufs_get_dma_info(ctx, &info);
2107 spin_unlock(&ctx->csa.register_lock);
2108 spu_release_saved(ctx);
2120 static void spufs_get_proxydma_info(struct spu_context *ctx,
2125 info->proxydma_info_type = ctx->csa.prob.dma_querytype_RW;
2126 info->proxydma_info_mask = ctx->csa.prob.dma_querymask_RW;
2127 info->proxydma_info_status = ctx->csa.prob.dma_tagstatus_R;
2131 struct mfc_cq_sr *puqp = &ctx->csa.priv2.puq[i];
2140 static ssize_t spufs_proxydma_info_dump(struct spu_context *ctx,
2145 spufs_get_proxydma_info(ctx, &info);
2152 struct spu_context *ctx = file->private_data;
2159 ret = spu_acquire_saved(ctx);
2162 spin_lock(&ctx->csa.register_lock);
2163 spufs_get_proxydma_info(ctx, &info);
2164 spin_unlock(&ctx->csa.register_lock);
2165 spu_release_saved(ctx);
2179 struct spu_context *ctx = s->private;
2181 seq_printf(s, "%d\n", ctx->tid);
2201 static unsigned long long spufs_acct_time(struct spu_context *ctx,
2204 unsigned long long time = ctx->stats.times[state];
2215 if (ctx->spu && ctx->stats.util_state == state) {
2216 time += ktime_get_ns() - ctx->stats.tstamp;
2222 static unsigned long long spufs_slb_flts(struct spu_context *ctx)
2224 unsigned long long slb_flts = ctx->stats.slb_flt;
2226 if (ctx->state == SPU_STATE_RUNNABLE) {
2227 slb_flts += (ctx->spu->stats.slb_flt -
2228 ctx->stats.slb_flt_base);
2234 static unsigned long long spufs_class2_intrs(struct spu_context *ctx)
2236 unsigned long long class2_intrs = ctx->stats.class2_intr;
2238 if (ctx->state == SPU_STATE_RUNNABLE) {
2239 class2_intrs += (ctx->spu->stats.class2_intr -
2240 ctx->stats.class2_intr_base);
2249 struct spu_context *ctx = s->private;
2252 ret = spu_acquire(ctx);
2258 ctx_state_names[ctx->stats.util_state],
2259 spufs_acct_time(ctx, SPU_UTIL_USER),
2260 spufs_acct_time(ctx, SPU_UTIL_SYSTEM),
2261 spufs_acct_time(ctx, SPU_UTIL_IOWAIT),
2262 spufs_acct_time(ctx, SPU_UTIL_IDLE_LOADED),
2263 ctx->stats.vol_ctx_switch,
2264 ctx->stats.invol_ctx_switch,
2265 spufs_slb_flts(ctx),
2266 ctx->stats.hash_flt,
2267 ctx->stats.min_flt,
2268 ctx->stats.maj_flt,
2269 spufs_class2_intrs(ctx),
2270 ctx->stats.libassist);
2271 spu_release(ctx);
2287 static inline int spufs_switch_log_used(struct spu_context *ctx)
2289 return (ctx->switch_log->head - ctx->switch_log->tail) %
2293 static inline int spufs_switch_log_avail(struct spu_context *ctx)
2295 return SWITCH_LOG_BUFSIZE - spufs_switch_log_used(ctx);
2300 struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2303 rc = spu_acquire(ctx);
2307 if (ctx->switch_log) {
2312 ctx->switch_log = kmalloc(struct_size(ctx->switch_log, log,
2315 if (!ctx->switch_log) {
2320 ctx->switch_log->head = ctx->switch_log->tail = 0;
2321 init_waitqueue_head(&ctx->switch_log->wait);
2325 spu_release(ctx);
2331 struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2334 rc = spu_acquire(ctx);
2338 kfree(ctx->switch_log);
2339 ctx->switch_log = NULL;
2340 spu_release(ctx);
2345 static int switch_log_sprint(struct spu_context *ctx, char *tbuf, int n)
2349 p = ctx->switch_log->log + ctx->switch_log->tail % SWITCH_LOG_BUFSIZE;
2364 struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2370 error = spu_acquire(ctx);
2378 if (spufs_switch_log_used(ctx) == 0) {
2392 * ctx->switch_log is stable).
2394 error = spufs_wait(ctx->switch_log->wait,
2395 spufs_switch_log_used(ctx) > 0);
2405 if (spufs_switch_log_used(ctx) == 0)
2410 width = switch_log_sprint(ctx, tbuf, sizeof(tbuf));
2412 ctx->switch_log->tail =
2413 (ctx->switch_log->tail + 1) %
2426 spu_release(ctx);
2434 struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2438 poll_wait(file, &ctx->switch_log->wait, wait);
2440 rc = spu_acquire(ctx);
2444 if (spufs_switch_log_used(ctx) > 0)
2447 spu_release(ctx);
2463 * Must be called with ctx->state_mutex held.
2465 void spu_switch_log_notify(struct spu *spu, struct spu_context *ctx,
2468 if (!ctx->switch_log)
2471 if (spufs_switch_log_avail(ctx) > 1) {
2474 p = ctx->switch_log->log + ctx->switch_log->head;
2481 ctx->switch_log->head =
2482 (ctx->switch_log->head + 1) % SWITCH_LOG_BUFSIZE;
2485 wake_up(&ctx->switch_log->wait);
2490 struct spu_context *ctx = s->private;
2493 mutex_lock(&ctx->state_mutex);
2494 if (ctx->spu) {
2495 struct spu *spu = ctx->spu;
2502 struct spu_state *csa = &ctx->csa;
2509 ctx->state == SPU_STATE_SAVED ? 'S' : 'R',
2510 ctx->flags,
2511 ctx->sched_flags,
2512 ctx->prio,
2513 ctx->time_slice,
2514 ctx->spu ? ctx->spu->number : -1,
2515 !list_empty(&ctx->rq) ? 'q' : ' ',
2516 ctx->csa.class_0_pending,
2517 ctx->csa.class_0_dar,
2518 ctx->csa.class_1_dsisr,
2520 ctx->ops->runcntl_read(ctx),
2521 ctx->ops->status_read(ctx));
2523 mutex_unlock(&ctx->state_mutex);
2607 { ".ctx", &spufs_ctx_fops, 0444, },