struct sint sadd(const struct sint *a, const struct sint *b) {
struct sint r, acp = *a, bcp = *b;
strim(&acp);
strim(&bcp);
for (int i = 0; i < MAX_DIGITS; i++)
r.digits[i] = '0';
r.digits[MAX_DIGITS] = '\0';
int lena = strlen(acp.digits);
int lenb = strlen(bcp.digits);
int carry = 0;
for (int i = 0; i < MAX_DIGITS; ++i) {
int cur = 0;
if (i < lena)
cur += acp.digits[lena - 1 - i] - '0';
if (i < lenb)
cur += bcp.digits[lenb - 1 - i] - '0';
cur += carry;
carry = cur / 10;
cur %= 10;
r.digits[MAX_DIGITS - 1 - i] = '0' + cur;
}
strim(&r);
return r;
}
static int bcm47xx_get_invariants(struct ssb_bus *bus,
struct ssb_init_invariants *iv)
{
char buf[20];
int len, err;
/* Fill boardinfo structure */
memset(&iv->boardinfo, 0 , sizeof(struct ssb_boardinfo));
len = bcm47xx_nvram_getenv("boardvendor", buf, sizeof(buf));
if (len > 0) {
err = kstrtou16(strim(buf), 0, &iv->boardinfo.vendor);
if (err)
pr_warn("Couldn't parse nvram board vendor entry with value \"%s\"\n",
buf);
}
if (!iv->boardinfo.vendor)
iv->boardinfo.vendor = SSB_BOARDVENDOR_BCM;
len = bcm47xx_nvram_getenv("boardtype", buf, sizeof(buf));
if (len > 0) {
err = kstrtou16(strim(buf), 0, &iv->boardinfo.type);
if (err)
pr_warn("Couldn't parse nvram board type entry with value \"%s\"\n",
buf);
}
memset(&iv->sprom, 0, sizeof(struct ssb_sprom));
bcm47xx_fill_sprom(&iv->sprom, NULL, false);
if (bcm47xx_nvram_getenv("cardbus", buf, sizeof(buf)) >= 0)
iv->has_cardbus_slot = !!simple_strtoul(buf, NULL, 10);
return 0;
}
/*
* read_file_line - read a line from a file
*
* Used to compose a filename from a printf format and to read a line from this
* file. All leading and trailing whitespaces (including line endings) are
* removed. The returned buffer must be freed with free(). This function is
* supposed for reading variable like content into a buffer, so files > 1024
* bytes are ignored.
*/
char *read_file_line(const char *fmt, ...)
{
va_list args;
char *filename;
char *buf, *line = NULL;
size_t size;
int ret;
struct stat s;
va_start(args, fmt);
filename = bvasprintf(fmt, args);
va_end(args);
ret = stat(filename, &s);
if (ret)
goto out;
if (s.st_size > 1024)
goto out;
buf = read_file(filename, &size);
if (!buf)
goto out;
line = strim(buf);
line = xstrdup(line);
free(buf);
out:
free(filename);
return line;
}
/*
Test if the version is acceptable based on the supplied critera.
The acceptable formats for criteria are:
VER Allows prereleases
1.2.[*xX] Wild card version portion. (allows prereleases).
~VER Compatible with VER at the least significant level.
~1.2.3 == (>=1.2.3 <1.3.0) Compatible at the patch level
~1.2 == 1.2.x Compatible at the minor level
~1 == 1.x Compatible at the major level
^VER Compatible with VER at the most significant level.
^0.2.3 == 0.2.3 <= VER < 0.3.0
^1.2.3 == 1.2.3 <= VER < 2.0.0
[>, >=, <, <=, ==, !=]VER Create range relative to given version
EXPR1 - EXPR2 <=EXPR1 <=EXPR2
EXPR1 || EXPR2 ... EXPR1 OR EXPR2
EXPR1 && EXPR2 ... EXPR1 AND EXPR2
EXPR1 EXPR2 ... EXPR1 AND EXPR2
Pre-release versions will only match if the criteria contains a "-.*" prerelease suffix
*/
PUBLIC bool mprIsVersionObjAcceptable(MprVersion *vp, cchar *criteria)
{
char *expr, *exprTok, *range, *rangeTok, *low, *high;
bool allMatched;
if (!vp->ok) {
return 0;
}
if (!criteria || *criteria == '\0') {
return 1;
}
criteria = cleanVersion(criteria);
for (range = (char*) criteria; stok(range, "||", &rangeTok) != 0; range = rangeTok) {
range = strim(range, " \t", 0);
allMatched = 1;
for (expr = (char*) range; sptok(expr, "&&", &exprTok) != 0; expr = exprTok) {
if (scontains(expr, " - ")) {
low = sptok(expr, " - ", &high);
return inRange(vp, sjoin(">=", low, NULL)) && inRange(vp, sjoin("<=", high, NULL));
}
if (!inRange(vp, expr)) {
allMatched = 0;
break;
}
}
if (allMatched) {
return 1;
}
}
return 0;
}
static ssize_t table_write(struct file *file,
const char __user *userbuf, size_t count, loff_t *ppos)
{
char buf[80];
int table_idx;
unsigned int cpu_freq;
int core_cap_level;
if (sizeof(buf) <= count)
return -EINVAL;
if (copy_from_user(buf, userbuf, count))
return -EFAULT;
/* terminate buffer and trim - white spaces may be appended
* at the end when invoked from shell command line */
buf[count] = '\0';
strim(buf);
if (sscanf(buf, "[%d] = %u %d",
&table_idx, &cpu_freq, &core_cap_level) != 3)
return -1;
if ((table_idx < 0) || (table_idx >= ARRAY_SIZE(throttle_table)))
return -EINVAL;
/* round new settings before updating table */
throttle_table[table_idx].cpu_freq = clip_to_table(cpu_freq);
throttle_table[table_idx].core_cap_level = (core_cap_level / 50) * 50;
return count;
}
/*
Check if the layout has changed. Returns false if the layout does not exist.
*/
static bool layoutIsStale(EspRoute *eroute, cchar *source, cchar *module)
{
char *data, *lpath, *quote;
cchar *layout, *layoutsDir;
ssize len;
bool stale;
int recompile;
stale = 0;
layoutsDir = httpGetDir(eroute->route, "LAYOUTS");
if ((data = mprReadPathContents(source, &len)) != 0) {
if ((lpath = scontains(data, "@ layout \"")) != 0) {
lpath = strim(&lpath[10], " ", MPR_TRIM_BOTH);
if ((quote = schr(lpath, '"')) != 0) {
*quote = '\0';
}
layout = (layoutsDir && *lpath) ? mprJoinPath(layoutsDir, lpath) : 0;
} else {
layout = (layoutsDir) ? mprJoinPath(layoutsDir, "default.esp") : 0;
}
if (layout) {
stale = espModuleIsStale(layout, module, &recompile);
if (stale) {
mprLog("info esp", 4, "esp layout %s is newer than module %s", layout, module);
}
}
}
return stale;
}
static ssize_t consumer_unregister_store(const char *s, size_t count)
{
char name[SYSEDP_NAME_LEN];
size_t n;
struct sysedp_consumer *consumer;
n = count > SYSEDP_NAME_LEN - 1 ? SYSEDP_NAME_LEN - 1 : count;
strncpy(name, s, n);
name[n] = 0;
consumer = sysedp_get_consumer(strim(name));
if (!consumer)
return -EINVAL;
if (!consumer->removable)
return -EINVAL;
sysedp_unregister_consumer(consumer);
kfree(consumer->states);
kfree(consumer->ocpeaks);
kfree(consumer);
return count;
}
/* Special entry to just crash directly. Available without KPROBEs */
static ssize_t direct_entry(struct file *f, const char __user *user_buf,
size_t count, loff_t *off)
{
enum ctype type;
char *buf;
if (count >= PAGE_SIZE)
return -EINVAL;
if (count < 1)
return -EINVAL;
buf = (char *)__get_free_page(GFP_KERNEL);
if (!buf)
return -ENOMEM;
if (copy_from_user(buf, user_buf, count)) {
free_page((unsigned long) buf);
return -EFAULT;
}
/* NULL-terminate and remove enter */
buf[count] = '\0';
strim(buf);
type = parse_cp_type(buf, count);
free_page((unsigned long) buf);
if (type == CT_NONE)
return -EINVAL;
pr_info("Performing direct entry %s\n", cp_type_to_str(type));
lkdtm_do_action(type);
*off += count;
return count;
}
static ssize_t do_register_entry(enum cname which, struct file *f,
const char __user *user_buf, size_t count, loff_t *off)
{
char *buf;
int err;
if (count >= PAGE_SIZE)
return -EINVAL;
buf = (char *)__get_free_page(GFP_KERNEL);
if (!buf)
return -ENOMEM;
if (copy_from_user(buf, user_buf, count)) {
free_page((unsigned long) buf);
return -EFAULT;
}
/* NULL-terminate and remove enter */
buf[count] = '\0';
strim(buf);
cptype = parse_cp_type(buf, count);
free_page((unsigned long) buf);
if (cptype == CT_NONE)
return -EINVAL;
err = lkdtm_register_cpoint(which);
if (err < 0)
return err;
*off += count;
return count;
}
static ssize_t
set_otg_mode(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct mv_otg *mvotg = dev_get_drvdata(dev);
char *usage = "Usage: $echo host/client to switch otg mode";
char buff[16], *b;
BUG_ON(mvotg != the_transceiver);
strncpy(buff, buf, sizeof(buff));
b = strim(buff);
pr_info("OTG state is %s\n", state_string[mvotg->otg.state]);
if (!strcmp(b, "host")) {
if (mvotg->otg.state == OTG_STATE_B_PERIPHERAL) {
pr_err("Failed to swich mode, pls don't connect to PC!\n");
return count;
}
otg_force_host_mode = 1;
} else if (!strcmp(b, "client")) {
otg_force_host_mode = 0;
} else {
pr_err("%s\n", usage);
return count;
}
mv_otg_run_state_machine(mvotg, 0);
return count;
}
static int diag224_idx2name(int index, char *name)
{
memcpy(name, diag224_cpu_names + ((index + 1) * DIAG204_CPU_NAME_LEN),
DIAG204_CPU_NAME_LEN);
name[DIAG204_CPU_NAME_LEN] = 0;
strim(name);
return 0;
}
int AGITool_Init(AGI_TOOLS *tool)
{
char buffer[1024], *field, *value;
// open stdin
tool->in = stdin;
// open stdout
tool->out = stdout;
/*
* Often contains any/all of the following:
* agi_network - value is yes if this is a fastagi
* agi_network_script - name of the script to execute
* agi_request - name of agi script
* agi_channel - current channel
* agi_language - current language
* agi_type - channel type (SIP, ZAP, IAX, ...)
* agi_uniqueid - unique id based on unix time
* agi_callerid - callerID string
* agi_dnid - dialed number id
* agi_rdnis - referring DNIS number
* agi_context - current context
* agi_extension - extension dialed
* agi_priority - current priority
* agi_enhanced - value is 1.0 if started as an EAGI script
* agi_accountcode - set by SetAccount in the dialplan
*/
// read the request
tool->agi_vars=tool->settings=NULL;
if ( fgets(buffer,sizeof(buffer),stdin) ) {
while(strcmp(buffer, "\n") != 0) {
field=buffer;
value=strchr(buffer,':');
if (value) {
value[0]=0;
value+=2;
strim(value);
tool->agi_vars = AGITool_ListAddItem(tool->agi_vars, field,value);
}
if ( !fgets(buffer,sizeof(buffer),stdin) ) {
// if failed, may have lost pipe, but sigpipe is blocked.
break;
}
}
}
// These could be configured in an ini...
tool->settings = AGITool_ListAddItem(tool->settings, "tmpdir","/tmp/");
tool->settings = AGITool_ListAddItem(tool->settings, "festival_text2wave","text2wave");
tool->settings = AGITool_ListAddItem(tool->settings, "cepstral_swift","swift");
return 0;
}
/**
* hname_tail - find the last component of an hname
* @name: hname to find the base profile name component of (NOT NULL)
*
* Returns: the tail (base profile name) name component of an hname
*/
static const char *hname_tail(const char *hname)
{
char *split;
hname = strim((char *)hname);
for (split = strstr(hname, "//"); split; split = strstr(hname, "//"))
hname = split + 2;
return hname;
}
PUBLIC bool websProcessUploadData(Webs *wp)
{
char *line, *nextTok;
ssize len, nbytes;
bool canProceed;
line = 0;
canProceed = 1;
while (canProceed && !wp->finalized && wp->uploadState != UPLOAD_CONTENT_END) {
if (wp->uploadState == UPLOAD_BOUNDARY || wp->uploadState == UPLOAD_CONTENT_HEADER) {
/*
Parse the next input line
*/
line = wp->input.servp;
if ((nextTok = memchr(line, '\n', bufLen(&wp->input))) == 0) {
/* Incomplete line */
canProceed = 0;
break;
}
*nextTok++ = '\0';
nbytes = nextTok - line;
websConsumeInput(wp, nbytes);
strim(line, "\r", WEBS_TRIM_END);
len = strlen(line);
if (line[len - 1] == '\r') {
line[len - 1] = '\0';
}
}
switch (wp->uploadState) {
case 0:
initUpload(wp);
break;
case UPLOAD_BOUNDARY:
processContentBoundary(wp, line);
break;
case UPLOAD_CONTENT_HEADER:
processUploadHeader(wp, line);
break;
case UPLOAD_CONTENT_DATA:
canProceed = processContentData(wp);
if (bufLen(&wp->input) < wp->boundaryLen) {
/* Incomplete boundary - return to get more data */
canProceed = 0;
}
break;
case UPLOAD_CONTENT_END:
break;
}
}
bufCompact(&wp->input);
return canProceed;
}
int main(void) {
char in = 0;
int digit = 0;
struct sint current;
struct sint max;
max.digits[0]=0;
struct sint min;
for (int i=0; i<51; i++){
min.digits[i]='9';
}
struct sint acc;
acc.digits[0]=0;
while (scanf("%c", &in)!=EOF){
if (in > '9' || in < '0'){
current.digits[digit] = 0;
acc = sadd(¤t, &acc);
if (scomp(¤t, &max)==1) {
max = current;
}
if (scomp(&min, ¤t)==1) {
min = current;
}
digit = 0;
for (int i=0; i<51; i++){
current.digits[i]=0;
}
}
else {
current.digits[digit] = in;
digit++;
}
}
strim(&min);
strim(&max);
strim(&acc);
printf("min:%s\n", min.digits);
printf("max:%s\n", max.digits);
printf("sum:%s\n", acc.digits);
}
static inline void part_hdr__part_name(enum diag204_format type, void *hdr,
char *name)
{
if (type == DIAG204_INFO_SIMPLE)
memcpy(name, ((struct diag204_part_hdr *)hdr)->part_name,
DIAG204_LPAR_NAME_LEN);
else /* DIAG204_INFO_EXT */
memcpy(name, ((struct diag204_x_part_hdr *)hdr)->part_name,
DIAG204_LPAR_NAME_LEN);
EBCASC(name, DIAG204_LPAR_NAME_LEN);
name[DIAG204_LPAR_NAME_LEN] = 0;
strim(name);
}
static char *cleanVersion(cchar *version)
{
char *cp;
cp = strim(version, " \tv=", 0);
if (schr(cp, 'X')) {
cp = sreplace(cp, "X", "x");
}
if (schr(cp, '*')) {
cp = sreplace(cp, "*", "x");
}
return cp;
}
static int edp_reg_override_write(struct file *file,
const char __user *userbuf, size_t count, loff_t *ppos)
{
char buf[32], *end;
unsigned int edp_reg_override_mA_temp;
unsigned int edp_reg_override_mA_prev = edp_reg_override_mA;
if (sizeof(buf) <= count)
goto override_err;
if (copy_from_user(buf, userbuf, count))
goto override_err;
/* terminate buffer and trim - white spaces may be appended
* at the end when invoked from shell command line */
buf[count]='\0';
strim(buf);
edp_reg_override_mA_temp = simple_strtoul(buf, &end, 10);
if (*end != '\0')
goto override_err;
if (edp_reg_override_mA_temp >= regulator_cur)
goto override_err;
if (edp_reg_override_mA == edp_reg_override_mA_temp)
return count;
edp_reg_override_mA = edp_reg_override_mA_temp;
if (init_cpu_edp_limits_calculated()) {
/* Revert to previous override value if new value fails */
edp_reg_override_mA = edp_reg_override_mA_prev;
goto override_err;
}
if (tegra_cpu_set_speed_cap(NULL)) {
pr_err("FAILED: Set CPU freq cap with new VDD_CPU EDP table\n");
goto override_out;
}
pr_info("Reinitialized VDD_CPU EDP table with regulator current limit"
" %u mA\n", regulator_cur - edp_reg_override_mA);
return count;
override_err:
pr_err("FAILED: Reinitialize VDD_CPU EDP table with override \"%s\"",
buf);
override_out:
return -EINVAL;
}
static ssize_t mc96fr1196c_ir_send_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct mc96fr116c_data *data = dev_get_drvdata(dev);
unsigned int value;
char *string, *pstring;
int signal_length = 2; /* By default, 2 bytes for data length */
int ir_sum = 0;
int number_freq = 0;
int ret;
if (data->mode != MC96FR116C_USER_IR_MODE) {
dev_err(&data->client->dev, "%s: Not user IR mode.\n",
__func__);
return -EINVAL;
}
if (!mutex_trylock(&data->signal_mutex))
return -EBUSY;
string = (char*)kmalloc(size + 1, GFP_KERNEL);
strlcpy(string, buf, size);
pstring = strim(string);
while (pstring) {
char *curr_string;
curr_string = strsep(&pstring, " ,");
if (*curr_string == '\0')
continue;
ret = kstrtouint(curr_string, 0, &value);
if (!value)
break;
if (ret < 0) {
dev_err(dev, "Error: Invalid argument. Could not convert.\n");
goto out;
}
if (signal_length == 2) {
data->carrier_freq = value;
data->signal[2] = (value >> 16) & 0xFF;
data->signal[3] = (value >> 8) & 0xFF;
data->signal[4] = value & 0xFF;
signal_length += 3;
} else {
/*
Match a keyword in the content returned from the last request
Format is:
KEYWORD = value
*/
bool match(MprTestGroup *gp, char *key, char *value)
{
char *vp, *trim;
vp = lookupValue(gp, key);
if (vp == 0 && value == 0) {
return 1;
}
trim = strim(vp, "\"", MPR_TRIM_BOTH);
if (vp == 0 || value == 0 || scmp(trim, value) != 0) {
mprLog("appweb test match", 0, "Match %s failed. Got \"%s\" expected \"%s\"", key, vp, value);
mprLog("appweb test match", 0, "Content %s", gp->content);
return 0;
}
return 1;
}
static void int_to_ext_kekl(struct tape3592_kekl *in,
struct tape390_kekl *out)
{
memset(out, 0, sizeof(*out));
if(in->flags & 0x40)
out->type = TAPE390_KEKL_TYPE_HASH;
else
out->type = TAPE390_KEKL_TYPE_LABEL;
if(in->flags & 0x80)
out->type_on_tape = TAPE390_KEKL_TYPE_HASH;
else
out->type_on_tape = TAPE390_KEKL_TYPE_LABEL;
memcpy(out->label, in->label, sizeof(in->label));
EBCASC(out->label, sizeof(in->label));
strim(out->label);
}
static inline bool __split_insert_one_part(char *subject, char *begin, int32_t len, split_node_t *split_node, bool need_strim)
{
bool insert_ok = false;
/* begin, len */
split_node->part_len = len;
if (likely(need_strim)) {
begin = strim(begin, &(split_node->part_len));
}
if (PTR_NOT_NULL(begin) && split_node->part_len > 0) {
split_node->begin_offset = begin - subject;
insert_ok = true;
}
return insert_ok;
}
static ssize_t __alt_name_store(struct device *dev, const char *buf,
const size_t len)
{
char *input, *pos, *alt_name, **ns_altname;
ssize_t rc;
if (is_namespace_pmem(dev)) {
struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev);
ns_altname = &nspm->alt_name;
} else if (is_namespace_blk(dev)) {
struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev);
ns_altname = &nsblk->alt_name;
} else
return -ENXIO;
if (dev->driver || to_ndns(dev)->claim)
return -EBUSY;
input = kmemdup(buf, len + 1, GFP_KERNEL);
if (!input)
return -ENOMEM;
input[len] = '\0';
pos = strim(input);
if (strlen(pos) + 1 > NSLABEL_NAME_LEN) {
rc = -EINVAL;
goto out;
}
alt_name = kzalloc(NSLABEL_NAME_LEN, GFP_KERNEL);
if (!alt_name) {
rc = -ENOMEM;
goto out;
}
kfree(*ns_altname);
*ns_altname = alt_name;
sprintf(*ns_altname, "%s", pos);
rc = len;
out:
kfree(input);
return rc;
}
static int do_readf(int argc, char *argv[])
{
unsigned char *buf = NULL, *val;
char *variable, *filename;
struct stat s;
size_t size;
int ret, i;
if (argc != 3)
return COMMAND_ERROR_USAGE;
filename = argv[1];
variable = argv[2];
ret = stat(filename, &s);
if (ret)
goto out;
if (s.st_size > 1024) {
ret = -EFBIG;
goto out;
}
buf = read_file(filename, &size);
if (!buf)
goto out;
for (i = 0; i < size; i++) {
if (!isprint(buf[i])) {
buf[i] = '\0';
break;
}
}
val = strim(buf);
ret = setenv(variable, val);
out:
free(buf);
return ret;
}
ssize_t read_string_list(const char *buf, const char * const list[])
{
size_t i;
char *s, *d = strdup(buf);
if (!d)
return -ENOMEM;
s = strim(d);
for (i = 0; list[i]; i++)
if (!strcmp(list[i], s))
break;
free(d);
if (!list[i])
return -EINVAL;
return i;
}
/*
Match a keyword an ignore case for windows
*/
bool matchAnyCase(MprTestGroup *gp, char *key, char *value)
{
char *vp, *trim;
vp = lookupValue(gp, key);
if (vp == 0 && value == 0) {
return 1;
}
trim = strim(vp, "\"", MPR_TRIM_BOTH);
#if BIT_WIN_LIKE
if (vp == 0 || scaselesscmp(trim, value) != 0)
#else
if (vp == 0 || value == 0 || scmp(trim, value) != 0)
#endif
{
mprLog("appweb test match", 0, "Match %s failed. Got %s expected %s", key, vp, value);
return 0;
}
return 1;
}
/**
* aa_split_fqname - split a fqname into a profile and namespace name
* @fqname: a full qualified name in namespace profile format (NOT NULL)
* @ns_name: pointer to portion of the string containing the ns name (NOT NULL)
*
* Returns: profile name or NULL if one is not specified
*
* Split a namespace name from a profile name (see policy.c for naming
* description). If a portion of the name is missing it returns NULL for
* that portion.
*
* NOTE: may modify the @fqname string. The pointers returned point
* into the @fqname string.
*/
char *aa_split_fqname(char *fqname, char **ns_name)
{
char *name = strim(fqname);
*ns_name = NULL;
if (name[0] == ':') {
char *split = strchr(&name[1], ':');
*ns_name = skip_spaces(&name[1]);
if (split) {
/* overwrite ':' with \0 */
*split = 0;
name = skip_spaces(split + 1);
} else
/* a ns name without a following profile is allowed */
name = NULL;
}
if (name && *name == 0)
name = NULL;
return name;
}
static ssize_t iso_res_realize_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
unsigned int bw;
unsigned int ult = 4;
char buff[50];
char *val, *s;
int ret;
struct tegra_bbc_proxy *bbc = dev_get_drvdata(dev);
strlcpy(buff, buf, sizeof(buff));
s = strim(buff);
/* first param is bw */
val = strsep(&s, ",");
ret = kstrtouint(val, 10, &bw);
if (ret) {
pr_err("invalid bw setting\n");
return -EINVAL;
}
/* second param is latency */
if (s) {
ret = kstrtouint(s, 10, &ult);
if (ret) {
pr_err("invalid latency setting\n");
return -EINVAL;
}
}
mutex_lock(&bbc->iso_lock);
bbc->last_bw = bw;
bbc->last_ult = ult;
ret = bbc_bw_request_unlocked(dev, 0, bw, ult, bbc->margin);
mutex_unlock(&bbc->iso_lock);
return ret ? ret : size;
}
/*
Read input from the console (stdin)
*/
static int consoleGets(EcStream *stream)
{
char prompt[MPR_MAX_STRING], *line, *cp;
int level;
if (stream->flags & EC_STREAM_EOL) {
return 0;
}
level = stream->compiler->state ? stream->compiler->state->blockNestCount : 0;
fmt(prompt, sizeof(prompt), "%s-%d> ", EJS_NAME, level);
mprYield(MPR_YIELD_STICKY);
line = readline(prompt);
mprResetYield();
if (line == NULL) {
stream->eof = 1;
mprPrintf("\n");
return -1;
}
cp = strim(line, "\r\n", MPR_TRIM_BOTH);
ecSetStreamBuf(stream, cp, slen(cp));
stream->flags |= EC_STREAM_EOL;
return (int) slen(cp);
}
static int __init init_fssuper(void)
{
struct super_block *sb;
struct block_device *bdev = NULL;
printk(KERN_INFO "Start module from here\t");
if(dev == NULL) {
printk(KERN_ERR "Device not specified");
return 0;
}
bdev = lookup_bdev(strim(dev));
if(IS_ERR(bdev)) {
if(bdev == ERR_PTR(-EBUSY))
printk(KERN_ERR "Device busy\t");
printk(KERN_ERR "Couldn't lock device <%ld>", PTR_ERR(bdev));
return 0;
}
sb = get_super(bdev);
bdput(bdev);
if(IS_ERR(sb)) {
printk(KERN_ERR "Can't load sb <%ld>", PTR_ERR(sb));
return 0;
}
printk(KERN_INFO "Sucessfuly loaded sb, uuid %x \t", *(sb->s_uuid));
printk(KERN_INFO "File system : %s \t", sb->s_type->name);
printk(KERN_INFO "Device: %x, super %x", bdev, sb);
return 0;
}
