Lines Matching refs:se
48 struct fuse_session *se;
134 struct fuse_session *se = req->se;
136 pthread_mutex_lock(&se->lock);
143 pthread_mutex_unlock(&se->lock);
148 static struct fuse_req *fuse_ll_alloc_req(struct fuse_session *se)
156 req->se = se;
166 static int fuse_send_msg(struct fuse_session *se, struct fuse_chan *ch,
171 assert(se != NULL);
173 if (se->debug) {
190 if (se->io != NULL)
191 /* se->io->writev is never NULL if se->io is not NULL as
193 res = se->io->writev(ch ? ch->fd : se->fd, iov, count,
194 se->userdata);
196 res = writev(ch ? ch->fd : se->fd, iov, count);
202 if (!fuse_session_exited(se) && err != ENOENT)
232 return fuse_send_msg(req->se, req->ch, iov, count);
420 size_t size = req->se->conn.proto_minor < 9 ?
425 if (!e->ino && req->se->conn.proto_minor < 4)
437 size_t entrysize = req->se->conn.proto_minor < 9 ?
453 size_t size = req->se->conn.proto_minor < 9 ?
493 static int fuse_send_data_iov_fallback(struct fuse_session *se,
512 return fuse_send_msg(se, ch, iov, iov_count);
530 res = fuse_send_msg(se, ch, iov, iov_count);
575 static struct fuse_ll_pipe *fuse_ll_get_pipe(struct fuse_session *se)
577 struct fuse_ll_pipe *llp = pthread_getspecific(se->pipe_key);
597 pthread_setspecific(se->pipe_key, llp);
604 static void fuse_ll_clear_pipe(struct fuse_session *se)
606 struct fuse_ll_pipe *llp = pthread_getspecific(se->pipe_key);
608 pthread_setspecific(se->pipe_key, NULL);
659 static int fuse_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
674 if (se->broken_splice_nonblock)
689 if (se->conn.proto_minor < 14 ||
690 !(se->conn.want & FUSE_CAP_SPLICE_WRITE))
693 llp = fuse_ll_get_pipe(se);
754 se->broken_splice_nonblock = 1;
756 pthread_setspecific(se->pipe_key, NULL);
813 res = fuse_send_msg(se, ch, iov, iov_count);
823 if (se->debug) {
831 (se->conn.want & FUSE_CAP_SPLICE_MOVE))
834 if (se->io != NULL && se->io->splice_send != NULL) {
835 res = se->io->splice_send(llp->pipe[0], NULL,
836 ch ? ch->fd : se->fd, NULL, out->len,
837 splice_flags, se->userdata);
839 res = splice(llp->pipe[0], NULL, ch ? ch->fd : se->fd, NULL,
856 fuse_ll_clear_pipe(se);
860 return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
863 static int fuse_send_data_iov(struct fuse_session *se, struct fuse_chan *ch,
870 return fuse_send_data_iov_fallback(se, ch, iov, iov_count, buf, len);
887 res = fuse_send_data_iov(req->se, req->ch, iov, 1, bufv, flags);
899 size_t size = req->se->conn.proto_minor < 4 ?
982 if (req->se->conn.proto_minor < 16) {
1102 if (req->se->op.lookup)
1103 req->se->op.lookup(req, nodeid, name);
1112 if (req->se->op.forget)
1113 req->se->op.forget(req, nodeid, arg->nlookup);
1127 if (req->se->op.forget_multi) {
1128 req->se->op.forget_multi(req, arg->count,
1130 } else if (req->se->op.forget) {
1135 dummy_req = fuse_ll_alloc_req(req->se);
1143 req->se->op.forget(dummy_req, forget->nodeid,
1157 if (req->se->conn.proto_minor >= 9) {
1167 if (req->se->op.getattr)
1168 req->se->op.getattr(req, nodeid, fip);
1177 if (req->se->op.setattr) {
1202 req->se->op.setattr(req, nodeid, &stbuf, arg->valid, fi);
1211 if (req->se->op.access)
1212 req->se->op.access(req, nodeid, arg->mask);
1221 if (req->se->op.readlink)
1222 req->se->op.readlink(req, nodeid);
1232 if (req->se->conn.proto_minor >= 12)
1237 if (req->se->op.mknod)
1238 req->se->op.mknod(req, nodeid, name, arg->mode, arg->rdev);
1247 if (req->se->conn.proto_minor >= 12)
1250 if (req->se->op.mkdir)
1251 req->se->op.mkdir(req, nodeid, PARAM(arg), arg->mode);
1260 if (req->se->op.unlink)
1261 req->se->op.unlink(req, nodeid, name);
1270 if (req->se->op.rmdir)
1271 req->se->op.rmdir(req, nodeid, name);
1281 if (req->se->op.symlink)
1282 req->se->op.symlink(req, linkname, nodeid, name);
1293 if (req->se->op.rename)
1294 req->se->op.rename(req, nodeid, oldname, arg->newdir, newname,
1306 if (req->se->op.rename)
1307 req->se->op.rename(req, nodeid, oldname, arg->newdir, newname,
1317 if (req->se->op.link)
1318 req->se->op.link(req, arg->oldnodeid, nodeid, PARAM(arg));
1327 if (req->se->op.create) {
1334 if (req->se->conn.proto_minor >= 12)
1339 req->se->op.create(req, nodeid, name, arg->mode, &fi);
1352 if (req->se->op.open)
1353 req->se->op.open(req, nodeid, &fi);
1362 if (req->se->op.read) {
1367 if (req->se->conn.proto_minor >= 9) {
1371 req->se->op.read(req, nodeid, arg->size, arg->offset, &fi);
1386 if (req->se->conn.proto_minor < 9) {
1394 if (req->se->op.write)
1395 req->se->op.write(req, nodeid, param, arg->size,
1404 struct fuse_session *se = req->se;
1416 if (se->conn.proto_minor < 9) {
1437 se->op.write_buf(req, nodeid, &bufv, arg->offset, &fi);
1442 fuse_ll_clear_pipe(se);
1453 if (req->se->conn.proto_minor >= 7)
1456 if (req->se->op.flush)
1457 req->se->op.flush(req, nodeid, &fi);
1470 if (req->se->conn.proto_minor >= 8) {
1479 if (req->se->op.release)
1480 req->se->op.release(req, nodeid, &fi);
1494 if (req->se->op.fsync)
1495 req->se->op.fsync(req, nodeid, datasync, &fi);
1508 if (req->se->op.opendir)
1509 req->se->op.opendir(req, nodeid, &fi);
1522 if (req->se->op.readdir)
1523 req->se->op.readdir(req, nodeid, arg->size, arg->offset, &fi);
1536 if (req->se->op.readdirplus)
1537 req->se->op.readdirplus(req, nodeid, arg->size, arg->offset, &fi);
1551 if (req->se->op.releasedir)
1552 req->se->op.releasedir(req, nodeid, &fi);
1566 if (req->se->op.fsyncdir)
1567 req->se->op.fsyncdir(req, nodeid, datasync, &fi);
1577 if (req->se->op.statfs)
1578 req->se->op.statfs(req, nodeid);
1590 struct fuse_session *se = req->se;
1591 unsigned int xattr_ext = !!(se->conn.want & FUSE_CAP_SETXATTR_EXT);
1598 if (req->se->op.setxattr)
1599 req->se->op.setxattr(req, nodeid, name, value, arg->size,
1609 if (req->se->op.getxattr)
1610 req->se->op.getxattr(req, nodeid, PARAM(arg), arg->size);
1619 if (req->se->op.listxattr)
1620 req->se->op.listxattr(req, nodeid, arg->size);
1629 if (req->se->op.removexattr)
1630 req->se->op.removexattr(req, nodeid, name);
1660 if (req->se->op.getlk)
1661 req->se->op.getlk(req, nodeid, &fi, &flock);
1694 if (req->se->op.flock)
1695 req->se->op.flock(req, nodeid, &fi, op);
1700 if (req->se->op.setlk)
1701 req->se->op.setlk(req, nodeid, &fi, &flock, sleep);
1717 static int find_interrupted(struct fuse_session *se, struct fuse_req *req)
1721 for (curr = se->list.next; curr != &se->list; curr = curr->next) {
1727 pthread_mutex_unlock(&se->lock);
1731 pthread_mutex_lock(&se->lock);
1735 pthread_mutex_unlock(&se->lock);
1740 pthread_mutex_lock(&se->lock);
1751 for (curr = se->interrupts.next; curr != &se->interrupts;
1762 struct fuse_session *se = req->se;
1765 if (se->debug)
1771 pthread_mutex_lock(&se->lock);
1772 if (find_interrupted(se, req)) {
1777 list_add_req(req, &se->interrupts);
1778 pthread_mutex_unlock(&se->lock);
1781 static struct fuse_req *check_interrupt(struct fuse_session *se,
1786 for (curr = se->interrupts.next; curr != &se->interrupts;
1797 curr = se->interrupts.next;
1798 if (curr != &se->interrupts) {
1810 if (req->se->op.bmap)
1811 req->se->op.bmap(req, nodeid, arg->blocksize, arg->block);
1824 !(req->se->conn.want & FUSE_CAP_IOCTL_DIR)) {
1832 if (sizeof(void *) == 4 && req->se->conn.proto_minor >= 16 &&
1837 if (req->se->op.ioctl)
1838 req->se->op.ioctl(req, nodeid, arg->cmd,
1859 if (req->se->op.poll) {
1869 ph->se = req->se;
1872 req->se->op.poll(req, nodeid, &fi, ph);
1886 if (req->se->op.fallocate)
1887 req->se->op.fallocate(req, nodeid, arg->mode, arg->offset, arg->length, &fi);
1904 if (req->se->op.copy_file_range)
1905 req->se->op.copy_file_range(req, nodeid_in, arg->off_in,
1921 if (req->se->op.lseek)
1922 req->se->op.lseek(req, nodeid, arg->offset, arg->whence, &fi);
1934 struct fuse_session *se = req->se;
1935 size_t bufsize = se->bufsize;
1940 if (se->debug) {
1948 se->conn.proto_major = arg->major;
1949 se->conn.proto_minor = arg->minor;
1950 se->conn.capable = 0;
1951 se->conn.want = 0;
1971 if (arg->max_readahead < se->conn.max_readahead)
1972 se->conn.max_readahead = arg->max_readahead;
1977 se->conn.capable |= FUSE_CAP_ASYNC_READ;
1979 se->conn.capable |= FUSE_CAP_POSIX_LOCKS;
1981 se->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
1983 se->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
1985 se->conn.capable |= FUSE_CAP_DONT_MASK;
1987 se->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
1989 se->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;
1991 se->conn.capable |= FUSE_CAP_READDIRPLUS;
1993 se->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;
1995 se->conn.capable |= FUSE_CAP_ASYNC_DIO;
1997 se->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
1999 se->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;
2001 se->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
2003 se->conn.capable |= FUSE_CAP_POSIX_ACL;
2005 se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
2007 se->conn.capable |= FUSE_CAP_CACHE_SYMLINKS;
2009 se->conn.capable |= FUSE_CAP_NO_OPENDIR_SUPPORT;
2011 se->conn.capable |= FUSE_CAP_EXPLICIT_INVAL_DATA;
2013 se->conn.capable |= FUSE_CAP_SETXATTR_EXT;
2023 se->conn.capable |= FUSE_CAP_EXPIRE_ONLY;
2025 se->conn.max_readahead = 0;
2028 if (se->conn.proto_minor >= 14) {
2031 if ((se->io == NULL) || (se->io->splice_send != NULL)) {
2032 se->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;
2035 if ((se->io == NULL) || (se->io->splice_receive != NULL)) {
2036 se->conn.capable |= FUSE_CAP_SPLICE_READ;
2040 if (se->conn.proto_minor >= 18)
2041 se->conn.capable |= FUSE_CAP_IOCTL_DIR;
2051 if ((cond) && (se->conn.capable & (cap))) \
2052 se->conn.want |= (cap)
2060 LL_SET_DEFAULT(se->op.write_buf, FUSE_CAP_SPLICE_READ);
2061 LL_SET_DEFAULT(se->op.getlk && se->op.setlk,
2063 LL_SET_DEFAULT(se->op.flock, FUSE_CAP_FLOCK_LOCKS);
2064 LL_SET_DEFAULT(se->op.readdirplus, FUSE_CAP_READDIRPLUS);
2065 LL_SET_DEFAULT(se->op.readdirplus && se->op.readdir,
2073 se->conn.time_gran = 1;
2080 se->bufsize = bufsize;
2082 if (se->conn.max_write > bufsize - FUSE_BUFFER_HEADER_SIZE)
2083 se->conn.max_write = bufsize - FUSE_BUFFER_HEADER_SIZE;
2085 se->got_init = 1;
2086 if (se->op.init)
2087 se->op.init(se->userdata, &se->conn);
2089 if (se->conn.want & (~se->conn.capable)) {
2092 se->conn.want & (~se->conn.capable));
2094 se->error = -EPROTO;
2095 fuse_session_exit(se);
2099 unsigned max_read_mo = get_max_read(se->mo);
2100 if (se->conn.max_read != max_read_mo) {
2103 se->conn.max_read, max_read_mo);
2105 se->error = -EPROTO;
2106 fuse_session_exit(se);
2110 if (se->conn.max_write < bufsize - FUSE_BUFFER_HEADER_SIZE) {
2111 se->bufsize = se->conn.max_write + FUSE_BUFFER_HEADER_SIZE;
2115 outarg.max_pages = (se->conn.max_write - 1) / getpagesize() + 1;
2122 if (se->conn.want & FUSE_CAP_ASYNC_READ)
2124 if (se->conn.want & FUSE_CAP_POSIX_LOCKS)
2126 if (se->conn.want & FUSE_CAP_ATOMIC_O_TRUNC)
2128 if (se->conn.want & FUSE_CAP_EXPORT_SUPPORT)
2130 if (se->conn.want & FUSE_CAP_DONT_MASK)
2132 if (se->conn.want & FUSE_CAP_FLOCK_LOCKS)
2134 if (se->conn.want & FUSE_CAP_AUTO_INVAL_DATA)
2136 if (se->conn.want & FUSE_CAP_READDIRPLUS)
2138 if (se->conn.want & FUSE_CAP_READDIRPLUS_AUTO)
2140 if (se->conn.want & FUSE_CAP_ASYNC_DIO)
2142 if (se->conn.want & FUSE_CAP_WRITEBACK_CACHE)
2144 if (se->conn.want & FUSE_CAP_POSIX_ACL)
2146 if (se->conn.want & FUSE_CAP_CACHE_SYMLINKS)
2148 if (se->conn.want & FUSE_CAP_EXPLICIT_INVAL_DATA)
2150 if (se->conn.want & FUSE_CAP_SETXATTR_EXT)
2160 outarg.max_readahead = se->conn.max_readahead;
2161 outarg.max_write = se->conn.max_write;
2162 if (se->conn.proto_minor >= 13) {
2163 if (se->conn.max_background >= (1 << 16))
2164 se->conn.max_background = (1 << 16) - 1;
2165 if (se->conn.congestion_threshold > se->conn.max_background)
2166 se->conn.congestion_threshold = se->conn.max_background;
2167 if (!se->conn.congestion_threshold) {
2168 se->conn.congestion_threshold =
2169 se->conn.max_background * 3 / 4;
2172 outarg.max_background = se->conn.max_background;
2173 outarg.congestion_threshold = se->conn.congestion_threshold;
2175 if (se->conn.proto_minor >= 23)
2176 outarg.time_gran = se->conn.time_gran;
2178 if (se->debug) {
2201 struct fuse_session *se = req->se;
2206 se->got_destroy = 1;
2207 if (se->op.destroy)
2208 se->op.destroy(se->userdata);
2240 struct fuse_session *se = req->se;
2244 pthread_mutex_lock(&se->lock);
2245 head = &se->notify_list;
2252 pthread_mutex_unlock(&se->lock);
2258 static int send_notify_iov(struct fuse_session *se, int notify_code,
2263 if (!se->got_init)
2271 return fuse_send_msg(se, NULL, iov, count);
2285 return send_notify_iov(ph->se, FUSE_NOTIFY_POLL, iov, 2);
2291 int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
2297 if (!se)
2300 if (se->conn.proto_minor < 12)
2310 return send_notify_iov(se, FUSE_NOTIFY_INVAL_INODE, iov, 2);
2325 * @param se the session object
2332 static int fuse_lowlevel_notify_entry(struct fuse_session *se, fuse_ino_t parent,
2339 if (!se)
2342 if (se->conn.proto_minor < 12)
2356 return send_notify_iov(se, FUSE_NOTIFY_INVAL_ENTRY, iov, 3);
2359 int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
2362 return fuse_lowlevel_notify_entry(se, parent, name, namelen, FUSE_LL_INVALIDATE);
2365 int fuse_lowlevel_notify_expire_entry(struct fuse_session *se, fuse_ino_t parent,
2368 if (!se)
2371 if (!(se->conn.capable & FUSE_CAP_EXPIRE_ONLY))
2374 return fuse_lowlevel_notify_entry(se, parent, name, namelen, FUSE_LL_EXPIRE_ONLY);
2378 int fuse_lowlevel_notify_delete(struct fuse_session *se,
2385 if (!se)
2388 if (se->conn.proto_minor < 18)
2401 return send_notify_iov(se, FUSE_NOTIFY_DELETE, iov, 3);
2404 int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
2414 if (!se)
2417 if (se->conn.proto_minor < 15)
2433 res = fuse_send_data_iov(se, NULL, iov, 2, bufv, flags);
2450 struct fuse_session *se = req->se;
2472 if (se->op.retrieve_reply) {
2473 se->op.retrieve_reply(req, rreq->cookie, ino,
2481 fuse_ll_clear_pipe(se);
2484 int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino,
2492 if (!se)
2495 if (se->conn.proto_minor < 15)
2502 pthread_mutex_lock(&se->lock);
2504 rreq->nreq.unique = se->notify_ctr++;
2506 list_add_nreq(&rreq->nreq, &se->notify_list);
2507 pthread_mutex_unlock(&se->lock);
2518 err = send_notify_iov(se, FUSE_NOTIFY_RETRIEVE, iov, 2);
2520 pthread_mutex_lock(&se->lock);
2522 pthread_mutex_unlock(&se->lock);
2531 return req->se->userdata;
2543 pthread_mutex_lock(&req->se->lock);
2546 pthread_mutex_unlock(&req->se->lock);
2556 pthread_mutex_lock(&req->se->lock);
2558 pthread_mutex_unlock(&req->se->lock);
2640 void fuse_session_process_buf(struct fuse_session *se,
2643 fuse_session_process_buf_int(se, buf, NULL);
2646 void fuse_session_process_buf_int(struct fuse_session *se,
2680 if (se->debug) {
2688 req = fuse_ll_alloc_req(se);
2699 fuse_send_msg(se, ch, &iov, 1);
2710 if (!se->got_init) {
2713 expected = se->cuse_data ? CUSE_INIT : FUSE_INIT;
2721 if (se->deny_others && in->uid != se->owner && in->uid != 0 &&
2735 pthread_mutex_lock(&se->lock);
2736 intr = check_interrupt(se, req);
2737 list_add_req(req, &se->list);
2738 pthread_mutex_unlock(&se->lock);
2744 (in->opcode != FUSE_WRITE || !se->op.write_buf) &&
2766 if (in->opcode == FUSE_WRITE && se->op.write_buf)
2781 fuse_ll_clear_pipe(se);
2813 void fuse_session_destroy(struct fuse_session *se)
2817 if (se->got_init && !se->got_destroy) {
2818 if (se->op.destroy)
2819 se->op.destroy(se->userdata);
2821 llp = pthread_getspecific(se->pipe_key);
2824 pthread_key_delete(se->pipe_key);
2825 pthread_mutex_destroy(&se->lock);
2826 free(se->cuse_data);
2827 if (se->fd != -1)
2828 close(se->fd);
2829 if (se->io != NULL)
2830 free(se->io);
2831 destroy_mount_opts(se->mo);
2832 free(se);
2842 int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf)
2844 return fuse_session_receive_buf_int(se, buf, NULL);
2847 int fuse_session_receive_buf_int(struct fuse_session *se, struct fuse_buf *buf,
2853 size_t bufsize = se->bufsize;
2857 if (se->conn.proto_minor < 14 || !(se->conn.want & FUSE_CAP_SPLICE_READ))
2860 llp = fuse_ll_get_pipe(se);
2880 if (se->io != NULL && se->io->splice_receive != NULL) {
2881 res = se->io->splice_receive(ch ? ch->fd : se->fd, NULL,
2883 se->userdata);
2885 res = splice(ch ? ch->fd : se->fd, NULL, llp->pipe[1], NULL,
2890 if (fuse_session_exited(se))
2897 fuse_session_exit(se);
2927 buf->mem = malloc(se->bufsize);
2934 buf->size = se->bufsize;
2942 fuse_ll_clear_pipe(se);
2947 fuse_ll_clear_pipe(se);
2964 buf->mem = malloc(se->bufsize);
2973 if (se->io != NULL) {
2974 /* se->io->read is never NULL if se->io is not NULL as
2976 res = se->io->read(ch ? ch->fd : se->fd, buf->mem, se->bufsize,
2977 se->userdata);
2979 res = read(ch ? ch->fd : se->fd, buf->mem, se->bufsize);
2983 if (fuse_session_exited(se))
2994 fuse_session_exit(se);
3019 struct fuse_session *se;
3032 se = (struct fuse_session *) calloc(1, sizeof(struct fuse_session));
3033 if (se == NULL) {
3037 se->fd = -1;
3038 se->conn.max_write = UINT_MAX;
3039 se->conn.max_readahead = UINT_MAX;
3042 if(fuse_opt_parse(args, se, fuse_ll_opts, NULL) == -1)
3044 if(se->deny_others) {
3071 if (se->debug)
3074 se->bufsize = FUSE_MAX_MAX_PAGES * getpagesize() +
3077 list_init_req(&se->list);
3078 list_init_req(&se->interrupts);
3079 list_init_nreq(&se->notify_list);
3080 se->notify_ctr = 1;
3081 pthread_mutex_init(&se->lock, NULL);
3083 err = pthread_key_create(&se->pipe_key, fuse_ll_pipe_destructor);
3090 memcpy(&se->op, op, op_size);
3091 se->owner = getuid();
3092 se->userdata = userdata;
3094 se->mo = mo;
3095 return se;
3098 pthread_mutex_destroy(&se->lock);
3105 free(se);
3110 int fuse_session_custom_io(struct fuse_session *se, const struct fuse_custom_io *io,
3132 se->io = malloc(sizeof(struct fuse_custom_io));
3133 if (se->io == NULL) {
3139 se->fd = fd;
3140 *se->io = *io;
3144 int fuse_session_mount(struct fuse_session *se, const char *mountpoint)
3172 se->fd = fd;
3177 fd = fuse_kern_mount(mountpoint, se->mo);
3180 se->fd = fd;
3183 se->mountpoint = strdup(mountpoint);
3184 if (se->mountpoint == NULL)
3194 int fuse_session_fd(struct fuse_session *se)
3196 return se->fd;
3199 void fuse_session_unmount(struct fuse_session *se)
3201 if (se->mountpoint != NULL) {
3202 fuse_kern_unmount(se->mountpoint, se->fd);
3203 se->fd = -1;
3204 free(se->mountpoint);
3205 se->mountpoint = NULL;
3282 void fuse_session_exit(struct fuse_session *se)
3284 se->exited = 1;
3288 void fuse_session_reset(struct fuse_session *se)
3290 se->exited = 0;
3291 se->error = 0;
3295 int fuse_session_exited(struct fuse_session *se)
3297 return se->exited;